Add view, positional args, errors gold, and bytecode backend.
Reorganize examples into structure/keywords/errors, launch marqdo view for AST-backed browsing, and ship an M5 stack VM selectable via --backend. Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
1 parent
a29bf6e97b
commit
ac0a3fbced
48 files changed
+3007
-202
No files matched your search
Generated
+37
@@ -67,6 +67,12 @@ version = "1.0.104"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "330a5ed07fa54e4702c9d6c4174f74427fc0ef6e214bbd677ae50a5099946470"
|
||||
|
||||
[[package]]
|
||||
name = "ascii"
|
||||
version = "1.1.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "d92bec98840b8f03a5ff5413de5293bfcd8bf96467cf5452609f939ec6f5de16"
|
||||
|
||||
[[package]]
|
||||
name = "assert_cmd"
|
||||
version = "2.0.14"
|
||||
@@ -99,6 +105,12 @@ dependencies = [
|
||||
"serde_core",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "chunked_transfer"
|
||||
version = "1.5.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "6e4de3bc4ea267985becf712dc6d9eed8b04c953b3fcfb339ebc87acd9804901"
|
||||
|
||||
[[package]]
|
||||
name = "clap"
|
||||
version = "4.4.18"
|
||||
@@ -172,6 +184,12 @@ version = "0.4.1"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
|
||||
|
||||
[[package]]
|
||||
name = "httpdate"
|
||||
version = "1.0.3"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "df3b46402a9d5adb4c86a0cf463f42e19994e3ee891101b1841f30a545cb49a9"
|
||||
|
||||
[[package]]
|
||||
name = "is_terminal_polyfill"
|
||||
version = "1.70.2"
|
||||
@@ -184,6 +202,12 @@ version = "0.2.189"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
|
||||
|
||||
[[package]]
|
||||
name = "log"
|
||||
version = "0.4.33"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "0ceec5bc11778974d1bcb055b18002eba7f4b3518b6a0081b3af5f21666da9ad"
|
||||
|
||||
[[package]]
|
||||
name = "marqdo"
|
||||
version = "0.1.0"
|
||||
@@ -193,6 +217,7 @@ dependencies = [
|
||||
"clap",
|
||||
"predicates",
|
||||
"thiserror",
|
||||
"tiny_http",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
@@ -373,6 +398,18 @@ dependencies = [
|
||||
"syn 2.0.119",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "tiny_http"
|
||||
version = "0.12.0"
|
||||
source = "registry+https://github.com/rust-lang/crates.io-index"
|
||||
checksum = "389915df6413a2e74fb181895f933386023c71110878cd0825588928e64cdc82"
|
||||
dependencies = [
|
||||
"ascii",
|
||||
"chunked_transfer",
|
||||
"httpdate",
|
||||
"log",
|
||||
]
|
||||
|
||||
[[package]]
|
||||
name = "unicode-ident"
|
||||
version = "1.0.24"
|
||||
|
||||
@@ -15,6 +15,7 @@ path = "src/main.rs"
|
||||
anyhow = "1"
|
||||
clap = { version = "=4.4.18", features = ["derive"] }
|
||||
thiserror = "1"
|
||||
tiny_http = "0.12"
|
||||
|
||||
[dev-dependencies]
|
||||
assert_cmd = "=2.0.14"
|
||||
|
||||
@@ -4,7 +4,7 @@
|
||||
|
||||
Marqdo:Markdown **标记即语法**。源文件 `.mq.md` 既是文稿也是程序。
|
||||
|
||||
语法宪法:[doc/design/markdown-mapping.md](doc/design/markdown-mapping.md) · 关键字:[keywords.md](doc/design/keywords.md) · 示例:[examples/](examples/)
|
||||
语法宪法:[doc/design/markdown-mapping.md](doc/design/markdown-mapping.md) · 调用实参:[call-arguments.md](doc/design/call-arguments.md) · 示例布局:[examples-and-tests.md](doc/design/examples-and-tests.md) · 浏览:[view.md](doc/design/view.md) · 示例:[examples/](examples/)
|
||||
|
||||
---
|
||||
|
||||
@@ -48,16 +48,18 @@ Marqdo:Markdown **标记即语法**。源文件 `.mq.md` 既是文稿也是程
|
||||
|
||||
- 映射 v0.1:[markdown-mapping.md](doc/design/markdown-mapping.md)
|
||||
- 解释器路线图:[interpreter.md](doc/roadmap/interpreter.md)
|
||||
- **Phase I(树遍历)已通**:`examples/` 下 hello / index / branch / loop / collection / with-import 均可 `marqdo run`
|
||||
- **Phase I(树遍历)已通**:`examples/structure/` 与 `examples/keywords/` 金样例均可 `marqdo run`
|
||||
- **view**:`marqdo view examples` 按 AST 浏览结构与输出
|
||||
- 依赖(Rust,无 Flex/Bison):[dependencies.md](doc/design/dependencies.md)
|
||||
- 选型:[ADR 0001 — Rust](doc/adr/0001-implementation-language.md)
|
||||
|
||||
```bash
|
||||
cargo run -- run examples/index.mq.md
|
||||
# Hello World!
|
||||
cargo run -- run examples/structure/hello.mq.md
|
||||
cargo run -- run examples/structure/hello.mq.md --backend bytecode
|
||||
cargo run -- view examples --no-open
|
||||
```
|
||||
|
||||
下一步:按需加强语义诊断与表达式;Phase II 字节码见路线图 M5。
|
||||
M5 字节码见 [bytecode.md](doc/design/bytecode.md);errors 见 `examples/errors/`。
|
||||
|
||||
|
||||
---
|
||||
|
||||
@@ -23,6 +23,10 @@
|
||||
| [adr/0001-implementation-language.md](adr/0001-implementation-language.md) | **Accepted:Rust 参考解释器;不用 Flex/Bison** |
|
||||
| [design/dependencies.md](design/dependencies.md) | 依赖详单(无 Flex/Bison) |
|
||||
| [design/keywords.md](design/keywords.md) | **英文最小关键字 / 内置 `print` `input`** |
|
||||
| [design/call-arguments.md](design/call-arguments.md) | **调用:具名 + 位置实参** |
|
||||
| [design/examples-and-tests.md](design/examples-and-tests.md) | **示例即金样例目录布局** |
|
||||
| [design/view.md](design/view.md) | **`marqdo view` 源结构浏览器** |
|
||||
| [design/bytecode.md](design/bytecode.md) | **M5 字节码 / 双后端** |
|
||||
| [design/pipeline-debug.md](design/pipeline-debug.md) | **流水线 `--dump-*` 可视调试** |
|
||||
| [dev-setup.md](dev-setup.md) | 开发环境配置(Rust M0) |
|
||||
| [roadmap/interpreter.md](roadmap/interpreter.md) | 正经解释器路线图 |
|
||||
|
||||
@@ -0,0 +1,89 @@
|
||||
# Marqdo 字节码(M5 原型)
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| 状态 | 进行中(原型) |
|
||||
| 日期 | 2026-08-04 |
|
||||
| 相关 | [roadmap/interpreter.md](../roadmap/interpreter.md) · Phase I 树遍历 |
|
||||
|
||||
---
|
||||
|
||||
## 1. 目标
|
||||
|
||||
在保留树遍历后端(`--backend tree`,默认)的同时,提供栈式字节码 VM(`--backend bytecode`),使**核心金样例** stdout 与树遍历 bit 一致。
|
||||
|
||||
```
|
||||
.mq.md → load/parse → Module AST
|
||||
├─ tree-walk
|
||||
└─ compile → Chunk → VM
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 2. 指令集(草案 / 原型已实现子集)
|
||||
|
||||
| Op | 栈效应 | 说明 |
|
||||
|----|--------|------|
|
||||
| `Constant i` | → v | 常量池 |
|
||||
| `True` / `False` / `None` | → b | |
|
||||
| `Pop` | v → | |
|
||||
| `GetLocal i` / `SetLocal i` | | 当前帧槽 |
|
||||
| `GetGlobal i` / `SetGlobal i` | | 名字在常量池(文本) |
|
||||
| `Add` `Sub` `Mul` `Div` `Negate` `Not` | | |
|
||||
| `Equal` `NotEqual` `Greater` `GreaterEqual` `Less` `LessEqual` | | |
|
||||
| `Jump a` / `JumpIfFalse a` / `JumpBack a` | | 相对/绝对跳转(原型用绝对 u16) |
|
||||
| `Print` | v → | 弹出并写 stdout |
|
||||
| `BuildList n` | v… → list | |
|
||||
| `GetIndex` | list, i → v | foreach 用 |
|
||||
| `Call f argc` | args… → ret | 用户函数(按形参序压栈) |
|
||||
| `Return` | | 返回 / 结束帧 |
|
||||
| `Interp n` | parts… → text | n 个交错 Lit/Var 标记后的拼接(简化:编译期展开为常量+拼接) |
|
||||
|
||||
原型实现以 `src/bytecode/` 为准;未列出的 Op 不存在于当前构建。
|
||||
|
||||
---
|
||||
|
||||
## 3. 编译约定
|
||||
|
||||
- 每个 Marqdo `Function` → 一个 `FnChunk`(含 `name`、`params`、`code`、`constants`)。
|
||||
- 模块级 `Program`:函数表 + 入口名(`main` 或唯一无参 level-1)。
|
||||
- 局部变量:函数体内首次赋值/形参分配槽位。
|
||||
- 嵌套 `##`:编入同一 `Program`,按名 `Call`;查找规则对齐树遍历(子树优先,再顶层)。
|
||||
- `and` / `or`:短接跳转。
|
||||
- 分支 / while:`JumpIfFalse` + `Jump` / `JumpBack`。
|
||||
- foreach:`BuildList` 或已有 list 全局/局部 → 索引循环。
|
||||
|
||||
---
|
||||
|
||||
## 4. 覆盖表(M5 原型)
|
||||
|
||||
| 金样例 | tree | bytecode |
|
||||
|--------|------|----------|
|
||||
| `structure/hello` | ✅ | ✅ |
|
||||
| `structure/branch` | ✅ | ✅ |
|
||||
| `structure/loop` | ✅ | ✅ |
|
||||
| `structure/collection` | ✅ | ✅ |
|
||||
| `keywords/print` | ✅ | ✅ |
|
||||
| `keywords/bool-logic` | ✅ | ✅ |
|
||||
| `structure/nested-call` | ✅ | ✅ |
|
||||
| `structure/positional-call` | ✅ | ✅ |
|
||||
| `structure/import/*` | ✅ | ✅(load 合并 AST 后编译) |
|
||||
| `examples/errors/*` | ✅(非零退出) | 同 tree 语义(编译期/运行期诊断) |
|
||||
|
||||
核心金样例双后端已对齐;后续可扩展 Op、优化与更好的调试信息。
|
||||
|
||||
---
|
||||
|
||||
## 5. CLI
|
||||
|
||||
```bash
|
||||
marqdo run FILE --backend tree # 默认
|
||||
marqdo run FILE --backend bytecode
|
||||
marqdo run FILE --dump-bytecode # 反汇编后仍可按 backend 执行
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
## 6. 非目标(本原型)
|
||||
|
||||
优化、寄存器分配、GC、与树遍历指令级调试对齐、独立 sema IR。
|
||||
@@ -0,0 +1,50 @@
|
||||
# 调用实参:具名与位置
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| 状态 | 已定(v0.1 增补) |
|
||||
| 日期 | 2026-08-04 |
|
||||
| 相关 | [markdown-mapping.md](markdown-mapping.md) · [keywords.md](keywords.md) |
|
||||
|
||||
---
|
||||
|
||||
## 1. 目标
|
||||
|
||||
`>` 调用同时支持:
|
||||
|
||||
| 形式 | 示例 | 说明 |
|
||||
|------|------|------|
|
||||
| **具名**(保留) | `> 问候 谁=Marqdo` | `名=值`;值可含空格(至下一 `名=`) |
|
||||
| **位置**(新增) | `> 问候 Marqdo` | 按形参声明顺序绑定 |
|
||||
|
||||
二者可混用:位置实参按「尚未被具名绑定的形参」从左到右填充。具名不可绑定同一形参两次;位置实参不得出现在「已出现具名实参」之后(对齐常见「位置在前、关键字在后」习惯)。
|
||||
|
||||
---
|
||||
|
||||
## 2. 文法(调用尾部)
|
||||
|
||||
```
|
||||
call_tail ::= callee arg*
|
||||
arg ::= named | positional
|
||||
named ::= ident '=' value
|
||||
positional ::= value_token
|
||||
```
|
||||
|
||||
- `value`(具名右侧):可含空格与 `` `var` `` 插值,直到下一个 `ident=` 边界。
|
||||
- `value_token`(位置):空白分隔的一个词法单元——数字、`` `名` ``、标识/文本词;**不含空格**。多词字符串请用具名,例如 `> print text=Hello World!`。
|
||||
- 内置 `print` 形参名为 `text`:`> print Hi` 与 `> print text=Hi` 等价。
|
||||
|
||||
---
|
||||
|
||||
## 3. 绑定算法
|
||||
|
||||
1. 收集具名 → 映射;冲突则报错。
|
||||
2. 按函数形参表顺序:若具名已提供则用之,否则取下一个位置实参。
|
||||
3. 位置实参有余、或必填形参仍缺 → 报错(内置 `input` 的 `prompt` 可缺省)。
|
||||
4. 用户函数:额外具名键仍写入调用环境(便于扩展);位置实参不可超过形参数目。
|
||||
|
||||
---
|
||||
|
||||
## 4. 金样例
|
||||
|
||||
见 `examples/structure/positional-call.mq.md` 与更新后的 `examples/structure/import/`。
|
||||
@@ -152,7 +152,7 @@ spike/ # Python 风险探测存档(可保留,非运行
|
||||
```bash
|
||||
cargo build
|
||||
cargo test
|
||||
cargo run -- run examples/index.mq.md
|
||||
cargo run -- run examples/structure/nested-call.mq.md
|
||||
```
|
||||
|
||||
---
|
||||
|
||||
@@ -0,0 +1,76 @@
|
||||
# 示例与测试布局
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| 状态 | 已定 |
|
||||
| 日期 | 2026-08-04 |
|
||||
| 原则 | **示例即金样例**:`examples/**/*.mq.md` 由 `cargo test` / CI 跑通;`marqdo view` 也可直接浏览 |
|
||||
|
||||
---
|
||||
|
||||
## 1. 目录
|
||||
|
||||
```
|
||||
examples/
|
||||
README.md # 本树说明
|
||||
structure/ # 代码基础结构(Markup 架构)
|
||||
hello.mq.md
|
||||
nested-call.mq.md # 原 index:嵌套函数 + 调用
|
||||
positional-call.mq.md # 位置实参
|
||||
branch.mq.md
|
||||
loop.mq.md
|
||||
collection.mq.md
|
||||
import/
|
||||
main.mq.md # 原 with-import
|
||||
utils.mq.md
|
||||
keywords/ # 关键字与内置名
|
||||
print.mq.md
|
||||
bool-logic.mq.md # True/False/None、and/or/not
|
||||
errors/ # 期望失败(诊断文案稳定后再加金样例)
|
||||
.gitkeep
|
||||
```
|
||||
|
||||
Rust 集成测试:`tests/gold.rs` 扫描约定路径,比对 stdout。
|
||||
|
||||
---
|
||||
|
||||
## 2. 分类职责
|
||||
|
||||
| 类别 | 测什么 | 不测什么 |
|
||||
|------|--------|----------|
|
||||
| **structure** | `#`/`##`、形参、`>` 调用、`*`/`**`、`+`/`-`、表、导入、位置/具名实参 | 关键字边角 |
|
||||
| **keywords** | `True`/`False`/`None`、`and`/`or`/`not`、`print`/`input` 约定 | 复杂控制流(可极简) |
|
||||
| **errors** | 未定义名、实参错误、语法错误的诊断 | 成功路径 |
|
||||
|
||||
未单独建夹、但应覆盖的其它测试(放 `tests/` 单测或日后 `examples/runtime/`):
|
||||
|
||||
- **流水线调试**:`--dump-lines` / `--dump-ast` / `--trace-eval`
|
||||
- **CLI**:默认 `index.mq.md`、退出码
|
||||
- **view**:目录扫描、单文件页、执行区(见 [view.md](view.md))
|
||||
- **模块图**:循环导入拒绝
|
||||
|
||||
---
|
||||
|
||||
## 3. 金样例约定
|
||||
|
||||
每个可执行 `.mq.md` 在 `tests/gold.rs`(或旁路 `.out` 文件)登记期望 stdout。
|
||||
`errors/` 内文件登记期望 stderr 子串与非零退出码。
|
||||
|
||||
Frontmatter 可写:
|
||||
|
||||
```yaml
|
||||
---
|
||||
title: …
|
||||
expect_stdout: |
|
||||
line1
|
||||
line2
|
||||
---
|
||||
```
|
||||
|
||||
(可选;v0 先以测试代码内嵌期望为主。)
|
||||
|
||||
---
|
||||
|
||||
## 4. 与 `view` 的关系
|
||||
|
||||
`marqdo view examples` 按上述文件夹生成侧栏索引;`structure` / `keywords` 为一级分组。
|
||||
@@ -38,7 +38,7 @@
|
||||
|
||||
| 名称 | 作用 | 调用示例 |
|
||||
|------|------|----------|
|
||||
| `print` | 写到 stdout(副作用) | `> print text=Hello World!` |
|
||||
| `print` | 写到 stdout(副作用) | `> print text=Hello` 或 `> print Hello`(位置实参,见 [call-arguments.md](call-arguments.md)) |
|
||||
| `input` | 从 stdin 读一行(返回文本) | `*`name` = > input prompt=Name: *` |
|
||||
|
||||
参数约定(v0):
|
||||
|
||||
@@ -42,7 +42,7 @@ Markdown **标记即语法**。输出**不是**语言架构原语,而是内置
|
||||
| 体内 `-` | 循环 |
|
||||
| 体内 `+` 或 `1.` | 分支 |
|
||||
| 分支臂头整行恰为 `*` | else |
|
||||
| `> 函数 形参=实参` | 调用(含内置 `print` / `input`) |
|
||||
| `> 函数 形参=实参` 或 `> 函数 实参` | 调用(具名 / 位置,见 [call-arguments.md](call-arguments.md)) |
|
||||
| frontmatter `> path.mq.md` | 跨文件导入 |
|
||||
| `*…*` | **程序语句**(绑定、表达式句、可写的调用句等) |
|
||||
| `**…**` | **返回值**(架构级;函数结果) |
|
||||
|
||||
@@ -28,6 +28,8 @@ marqdo dump FILE --stage lines|tokens|ast|sema|all
|
||||
| `--dump-ast` | 语法 | S 表达式或缩进树(模块/函数/语句) |
|
||||
| `--dump-sema` | 语义 | 作用域、导入图、提升后的符号表 |
|
||||
| `--trace-eval` | 求值 | 进入/离开函数、绑定、分支臂选择、`print` 调用 |
|
||||
| `--dump-bytecode` | 字节码 | 反汇编 `Program`(见 [bytecode.md](bytecode.md)) |
|
||||
| `--backend tree\|bytecode` | 执行后端 | 默认 `tree`;`bytecode` 走栈式 VM |
|
||||
| `--dump-all` | 以上全部 | 按管道顺序打印,段之间用横幅分隔 |
|
||||
|
||||
格式约定:
|
||||
|
||||
@@ -0,0 +1,119 @@
|
||||
# `marqdo view` — 源结构浏览器
|
||||
|
||||
| | |
|
||||
|---|---|
|
||||
| 状态 | 已定(实现中) |
|
||||
| 日期 | 2026-08-04 |
|
||||
| 相关 | [examples-and-tests.md](examples-and-tests.md) · [pipeline-debug.md](pipeline-debug.md) · AST(`src/ast.rs`) |
|
||||
|
||||
---
|
||||
|
||||
## 1. 动机
|
||||
|
||||
`.mq.md` 既是文档也是程序。需要一种**可读渲染**,而不仅是纯文本或 `run` 的 stdout:
|
||||
|
||||
- 按语法树展示函数、分支、循环、调用、返回;
|
||||
- 同页展示**执行结果**;
|
||||
- 支持打开**单个文件**或**文件夹**(扫描全部 `.mq.md` + 结构索引)。
|
||||
|
||||
---
|
||||
|
||||
## 2. CLI
|
||||
|
||||
```bash
|
||||
marqdo view [PATH] [--port PORT] [--host HOST] [--no-open]
|
||||
```
|
||||
|
||||
| 参数 | 默认 | 说明 |
|
||||
|------|------|------|
|
||||
| `PATH` | `.` | `.mq.md` 文件,或目录(递归扫描 `*.mq.md`) |
|
||||
| `--port` | `7429` | HTTP 端口 |
|
||||
| `--host` | `127.0.0.1` | 仅本地 |
|
||||
| `--no-open` | 关 | 不尝试打开系统浏览器 |
|
||||
|
||||
示例:
|
||||
|
||||
```bash
|
||||
marqdo view examples/structure/hello.mq.md
|
||||
marqdo view examples
|
||||
marqdo view examples/keywords --port 8080
|
||||
```
|
||||
|
||||
启动后打印 `http://127.0.0.1:7429/`,阻塞直至 Ctrl+C。
|
||||
|
||||
---
|
||||
|
||||
## 3. 信息架构
|
||||
|
||||
### 3.1 目录模式
|
||||
|
||||
```
|
||||
┌─────────────┬──────────────────────────────────┐
|
||||
│ 索引 │ 选中文件 / 欢迎页 │
|
||||
│ structure/ │ │
|
||||
│ hello │ [源码结构] [执行结果] [原始文本] │
|
||||
│ branch │ │
|
||||
│ keywords/ │ │
|
||||
└─────────────┴──────────────────────────────────┘
|
||||
```
|
||||
|
||||
- 侧栏:相对 `PATH` 的目录树;只列出 `.mq.md`。
|
||||
- 点击文件:主区切换为该文件的三栏/三节视图。
|
||||
|
||||
### 3.2 单文件模式
|
||||
|
||||
无侧栏列表(或仅当前文件);主区同「选中文件」视图。仍提供「执行」结果。
|
||||
|
||||
---
|
||||
|
||||
## 4. 主区三节
|
||||
|
||||
### 4.1 源码结构(AST 渲染)
|
||||
|
||||
不依赖浏览器 Markdown 猜测语义,而用服务端已解析的 AST:
|
||||
|
||||
| AST 节点 | 视觉 |
|
||||
|----------|------|
|
||||
| `Function` | 卡片:标题层级、形参芯片、子函数嵌套;**中间的注释行仍展示**(来自源行分类,不在 AST 内) |
|
||||
| `Stmt::*` | 绑定 / 返回 / 调用 / 分支 / 循环;表达式用**表面语法**(如 `` `x` > 0 ``),不用 Debug |
|
||||
|
||||
样式:清晰分区,避免「通用仪表盘」堆砌;结构层级一眼可读。
|
||||
|
||||
### 4.2 执行结果
|
||||
|
||||
服务端对该文件跑与 `marqdo run` 相同的管线,**捕获 stdout/stderr** 与退出状态,展示在「输出」区。
|
||||
含 `input` 的程序:view 中标注「需交互,未在 view 执行」或提供只读说明(v0:跳过/失败信息)。
|
||||
|
||||
### 4.3 原始文本
|
||||
|
||||
等宽展示源文件;可选行分类着色(Code / Comment / Blank),与 `--dump-lines` 一致。
|
||||
|
||||
---
|
||||
|
||||
## 5. HTTP API(实现细节)
|
||||
|
||||
| 方法 | 路径 | 含义 |
|
||||
|------|------|------|
|
||||
| `GET` | `/` | 索引 HTML |
|
||||
| `GET` | `/file?path=…` | 单文件页(path 相对根,防 `..` 逃逸) |
|
||||
| `GET` | `/api/tree` | JSON 文件树 |
|
||||
| `GET` | `/api/file?path=…` | JSON:`{ source, ast_html 或 ast_json, stdout, stderr, ok }` |
|
||||
|
||||
v0 可全部服务端渲染 HTML,API 可选。
|
||||
|
||||
安全:根目录锁死为 CLI 给定的 `PATH`(若为文件则其父目录为根、仅一文件);拒绝根外路径。
|
||||
|
||||
---
|
||||
|
||||
## 6. 依赖
|
||||
|
||||
本地同步 HTTP 即可(如 `tiny_http`),无强制前端构建;HTML/CSS/少量 JS 内嵌于 Rust。
|
||||
|
||||
---
|
||||
|
||||
## 7. 验收
|
||||
|
||||
1. `marqdo view examples/structure/hello.mq.md` 显示结构 + `Hello World!` 输出。
|
||||
2. `marqdo view examples` 侧栏含 `structure/` 与 `keywords/` 分组。
|
||||
3. 分支/循环样例在结构区可区分臂与循环体。
|
||||
4. 路径逃逸被拒绝。
|
||||
+1
-1
@@ -33,7 +33,7 @@ cd marqdo
|
||||
|
||||
cargo build
|
||||
cargo test
|
||||
cargo run -- run examples/hello.mq.md
|
||||
cargo run -- run examples/structure/hello.mq.md
|
||||
```
|
||||
|
||||
当前 M0:`run` 会读入文件并明确报错「evaluation not implemented」(脚手架,非静默假成功)。
|
||||
|
||||
@@ -96,7 +96,7 @@ Phase I 对齐 Crafting Interpreters 的 **jlox(树遍历)**;Phase II 对
|
||||
2. **语法 → AST**:函数、形参、`*` 语句、`**` 返回、`>` 调用、`+` 分支、`-` 循环、表格集合、绑定与 `==`。
|
||||
3. **语义**:提升、嵌套作用域、`##` 私有、frontmatter 导入公有顶层。
|
||||
4. **运行时**:环境、调用栈、值(文/数/表/记录)、内置 `print`。
|
||||
5. **验收**:`examples/hello` … `with-import` 全部 `marqdo run` 通过。
|
||||
5. **验收**:`examples/structure/*` 与 `examples/keywords/*` 全部 `marqdo run` 通过。
|
||||
|
||||
### Phase II — 字节码 VM(正经化)
|
||||
|
||||
@@ -158,7 +158,7 @@ spike/ # Python 存档,非运行时依赖
|
||||
| M2 | 解析:函数、输出调用、返回 | `hello` + `index` 金样例绿 | ✅ |
|
||||
| M3 | 分支、循环、表格、绑定 | `branch`/`loop`/`collection` 绿 | ✅ |
|
||||
| M4 | 导入与提升 | `with-import` 绿;**宣称 Phase I 达标** | ✅ |
|
||||
| M5 | 字节码设计文档 + 原型 opcode | 同金样例双后端一致 | 未开始 |
|
||||
| M5 | 字节码设计文档 + 原型 opcode | 核心金样例双后端一致;覆盖表见 [bytecode.md](../design/bytecode.md) | 进行中 |
|
||||
|
||||
**Phase I 完成前,不宣称「语言已实现」。**
|
||||
**仅 hello 特判通过,不算完成。**
|
||||
@@ -170,9 +170,9 @@ spike/ # Python 存档,非运行时依赖
|
||||
在仓库根或任意含 `index.mq.md` 的目录:
|
||||
|
||||
```bash
|
||||
marqdo run examples/index.mq.md
|
||||
marqdo run examples/structure/nested-call.mq.md
|
||||
# 或
|
||||
cd examples && marqdo run
|
||||
marqdo run examples/structure/import/main.mq.md
|
||||
```
|
||||
|
||||
输出与金样例一致;错误带位置;新增语法必须加金样例与单测。这才是「一门解释型语言」的最低合格线。
|
||||
@@ -0,0 +1,15 @@
|
||||
# Marqdo examples(金样例)
|
||||
|
||||
本目录即测试夹具,见 [doc/design/examples-and-tests.md](../doc/design/examples-and-tests.md)。
|
||||
|
||||
| 目录 | 内容 |
|
||||
|------|------|
|
||||
| [`structure/`](structure/) | 函数、调用、分支、循环、表、导入、位置实参 |
|
||||
| [`keywords/`](keywords/) | `print`、布尔与 `and`/`or`/`not` |
|
||||
| [`errors/`](errors/) | 期望失败(未定义名 / 未知函数 / 实参 / 语法) |
|
||||
|
||||
```bash
|
||||
cargo test
|
||||
marqdo run examples/structure/hello.mq.md
|
||||
marqdo view examples
|
||||
```
|
||||
Whitespace-only changes.
@@ -0,0 +1,12 @@
|
||||
---
|
||||
title: bad arity
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
> needs_one
|
||||
|
||||
## needs_one
|
||||
- x
|
||||
|
||||
> print text=`x`
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
title: unrecognized code line
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
~not-valid-syntax
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
title: undefined variable
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
> print text=`missing`
|
||||
@@ -0,0 +1,7 @@
|
||||
---
|
||||
title: unknown function
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
> no_such_fn x=1
|
||||
@@ -0,0 +1,20 @@
|
||||
---
|
||||
title: 布尔与逻辑关键字
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
*`a` = True*
|
||||
*`b` = False*
|
||||
|
||||
+ `a` and not `b`
|
||||
> print text=ok
|
||||
+ *
|
||||
> print text=fail
|
||||
|
||||
*`probe` = 1*
|
||||
|
||||
+ None
|
||||
> print text=none-truthy
|
||||
+ *
|
||||
> print text=none-falsy
|
||||
@@ -0,0 +1,9 @@
|
||||
---
|
||||
title: 内置 print
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
> print text=named form
|
||||
|
||||
> print positional
|
||||
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -0,0 +1,19 @@
|
||||
---
|
||||
title: 位置实参
|
||||
description: `> fn value` binds by parameter order; named form still works
|
||||
---
|
||||
|
||||
# main
|
||||
|
||||
位置实参:
|
||||
|
||||
> 问候 Marqdo
|
||||
|
||||
具名实参(保留):
|
||||
|
||||
> 问候 谁=World
|
||||
|
||||
## 问候
|
||||
- 谁
|
||||
|
||||
> print text=Hello `谁`!
|
||||
+7
-1
@@ -60,7 +60,13 @@ pub struct BranchArm {
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct CallExpr {
|
||||
pub callee: String,
|
||||
pub args: Vec<(String, Expr)>,
|
||||
pub args: Vec<Arg>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub enum Arg {
|
||||
Positional(Expr),
|
||||
Named { name: String, value: Expr },
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
|
||||
@@ -0,0 +1,453 @@
|
||||
//! AST → bytecode Program.
|
||||
|
||||
use anyhow::{bail, Result};
|
||||
use std::collections::HashMap;
|
||||
|
||||
use crate::ast::{
|
||||
Arg, BinaryOp, CallExpr, Expr, Function, InterpPart, Literal, Module, Stmt, UnaryOp,
|
||||
};
|
||||
use crate::bytecode::{FnChunk, Op, Program};
|
||||
use crate::value::Value;
|
||||
|
||||
struct FlatFun {
|
||||
name: String,
|
||||
parent: Option<usize>,
|
||||
params: Vec<String>,
|
||||
body: Vec<Stmt>,
|
||||
children: Vec<usize>,
|
||||
}
|
||||
|
||||
pub fn compile_module(module: &Module) -> Result<Program> {
|
||||
let mut flat = Vec::new();
|
||||
for fun in &module.functions {
|
||||
collect_fun(fun, None, &mut flat);
|
||||
}
|
||||
if flat.is_empty() {
|
||||
bail!("bytecode: no functions to compile");
|
||||
}
|
||||
|
||||
let entry = flat
|
||||
.iter()
|
||||
.position(|f| f.name == "main" && f.parent.is_none())
|
||||
.or_else(|| {
|
||||
flat.iter()
|
||||
.position(|f| f.parent.is_none() && f.params.is_empty())
|
||||
})
|
||||
.ok_or_else(|| anyhow::anyhow!("bytecode: no entry function"))?;
|
||||
|
||||
let mut functions = Vec::new();
|
||||
for i in 0..flat.len() {
|
||||
functions.push(compile_function(i, &flat)?);
|
||||
}
|
||||
|
||||
Ok(Program { functions, entry })
|
||||
}
|
||||
|
||||
fn collect_fun(fun: &Function, parent: Option<usize>, flat: &mut Vec<FlatFun>) -> usize {
|
||||
let id = flat.len();
|
||||
flat.push(FlatFun {
|
||||
name: fun.name.clone(),
|
||||
parent,
|
||||
params: fun.params.clone(),
|
||||
body: fun.body.clone(),
|
||||
children: Vec::new(),
|
||||
});
|
||||
let mut child_ids = Vec::new();
|
||||
for child in &fun.children {
|
||||
child_ids.push(collect_fun(child, Some(id), flat));
|
||||
}
|
||||
flat[id].children = child_ids;
|
||||
id
|
||||
}
|
||||
|
||||
struct FnCompiler<'a> {
|
||||
flat: &'a [FlatFun],
|
||||
fn_id: usize,
|
||||
chunk: FnChunk,
|
||||
locals: HashMap<String, u8>,
|
||||
}
|
||||
|
||||
fn compile_function(fn_id: usize, flat: &[FlatFun]) -> Result<FnChunk> {
|
||||
let fun = &flat[fn_id];
|
||||
let mut locals = HashMap::new();
|
||||
for (i, p) in fun.params.iter().enumerate() {
|
||||
locals.insert(p.clone(), i as u8);
|
||||
}
|
||||
let mut c = FnCompiler {
|
||||
flat,
|
||||
fn_id,
|
||||
chunk: FnChunk {
|
||||
name: fun.name.clone(),
|
||||
params: fun.params.clone(),
|
||||
code: Vec::new(),
|
||||
constants: Vec::new(),
|
||||
locals: fun.params.clone(),
|
||||
},
|
||||
locals,
|
||||
};
|
||||
for stmt in &fun.body {
|
||||
c.compile_stmt(stmt)?;
|
||||
}
|
||||
c.emit(Op::None_);
|
||||
c.emit(Op::Return);
|
||||
let mut names = vec![String::new(); c.locals.len()];
|
||||
for (name, slot) in &c.locals {
|
||||
names[*slot as usize] = name.clone();
|
||||
}
|
||||
c.chunk.locals = names;
|
||||
Ok(c.chunk)
|
||||
}
|
||||
|
||||
impl<'a> FnCompiler<'a> {
|
||||
fn emit(&mut self, op: Op) {
|
||||
self.chunk.code.push(op);
|
||||
}
|
||||
|
||||
fn here(&self) -> u16 {
|
||||
self.chunk.code.len() as u16
|
||||
}
|
||||
|
||||
fn patch(&mut self, at: u16, op: Op) {
|
||||
self.chunk.code[at as usize] = op;
|
||||
}
|
||||
|
||||
fn add_const(&mut self, v: Value) -> u16 {
|
||||
if let Some(i) = self.chunk.constants.iter().position(|c| c == &v) {
|
||||
return i as u16;
|
||||
}
|
||||
let i = self.chunk.constants.len() as u16;
|
||||
self.chunk.constants.push(v);
|
||||
i
|
||||
}
|
||||
|
||||
fn local_slot(&mut self, name: &str) -> u8 {
|
||||
if let Some(&s) = self.locals.get(name) {
|
||||
return s;
|
||||
}
|
||||
let s = self.locals.len() as u8;
|
||||
self.locals.insert(name.to_string(), s);
|
||||
s
|
||||
}
|
||||
|
||||
fn resolve_call(&self, name: &str) -> Result<usize> {
|
||||
let fun = &self.flat[self.fn_id];
|
||||
for &cid in &fun.children {
|
||||
if self.flat[cid].name == name {
|
||||
return Ok(cid);
|
||||
}
|
||||
}
|
||||
let mut parent = fun.parent;
|
||||
while let Some(pid) = parent {
|
||||
for &cid in &self.flat[pid].children {
|
||||
if self.flat[cid].name == name {
|
||||
return Ok(cid);
|
||||
}
|
||||
}
|
||||
parent = self.flat[pid].parent;
|
||||
}
|
||||
for (i, f) in self.flat.iter().enumerate() {
|
||||
if f.parent.is_none() && f.name == name {
|
||||
return Ok(i);
|
||||
}
|
||||
}
|
||||
bail!("bytecode: unknown function `{name}`")
|
||||
}
|
||||
|
||||
fn compile_stmt(&mut self, stmt: &Stmt) -> Result<()> {
|
||||
match stmt {
|
||||
Stmt::Assign { name, value, .. } => {
|
||||
self.compile_expr(value)?;
|
||||
let slot = self.local_slot(name);
|
||||
self.emit(Op::SetLocal(slot));
|
||||
self.emit(Op::Pop);
|
||||
}
|
||||
Stmt::Return { value, .. } => {
|
||||
self.compile_expr(value)?;
|
||||
self.emit(Op::Return);
|
||||
}
|
||||
Stmt::Call { call, .. } => self.compile_call(call, true)?,
|
||||
Stmt::Branch { arms, .. } => {
|
||||
let mut end_jumps = Vec::new();
|
||||
for (i, arm) in arms.iter().enumerate() {
|
||||
let is_last = i + 1 == arms.len();
|
||||
let mut else_jump = None;
|
||||
if let Some(cond) = &arm.condition {
|
||||
self.compile_expr(cond)?;
|
||||
let jf = self.here();
|
||||
self.emit(Op::JumpIfFalse(0));
|
||||
else_jump = Some(jf);
|
||||
}
|
||||
for st in &arm.body {
|
||||
self.compile_stmt(st)?;
|
||||
}
|
||||
if !is_last {
|
||||
let j = self.here();
|
||||
self.emit(Op::Jump(0));
|
||||
end_jumps.push(j);
|
||||
}
|
||||
if let Some(jf) = else_jump {
|
||||
self.patch(jf, Op::JumpIfFalse(self.here()));
|
||||
}
|
||||
}
|
||||
let end = self.here();
|
||||
for j in end_jumps {
|
||||
self.patch(j, Op::Jump(end));
|
||||
}
|
||||
}
|
||||
Stmt::While {
|
||||
condition, body, ..
|
||||
} => {
|
||||
let loop_start = self.here();
|
||||
self.compile_expr(condition)?;
|
||||
let exit_j = self.here();
|
||||
self.emit(Op::JumpIfFalse(0));
|
||||
for st in body {
|
||||
self.compile_stmt(st)?;
|
||||
}
|
||||
self.emit(Op::Jump(loop_start));
|
||||
self.patch(exit_j, Op::JumpIfFalse(self.here()));
|
||||
}
|
||||
Stmt::ForEach {
|
||||
item,
|
||||
collection,
|
||||
body,
|
||||
..
|
||||
} => {
|
||||
self.compile_expr(&Expr::Var(collection.clone()))?;
|
||||
let coll_slot = self.local_slot(&format!("__coll_{collection}"));
|
||||
self.emit(Op::SetLocal(coll_slot));
|
||||
self.emit(Op::Pop);
|
||||
let i_slot = self.local_slot(&format!("__i_{collection}"));
|
||||
let zero = self.add_const(Value::Int(0));
|
||||
self.emit(Op::Constant(zero));
|
||||
self.emit(Op::SetLocal(i_slot));
|
||||
self.emit(Op::Pop);
|
||||
let item_slot = self.local_slot(item);
|
||||
|
||||
let loop_start = self.here();
|
||||
self.emit(Op::GetLocal(i_slot));
|
||||
self.emit(Op::GetLocal(coll_slot));
|
||||
self.emit(Op::Len);
|
||||
self.emit(Op::Less);
|
||||
let exit_j = self.here();
|
||||
self.emit(Op::JumpIfFalse(0));
|
||||
|
||||
self.emit(Op::GetLocal(coll_slot));
|
||||
self.emit(Op::GetLocal(i_slot));
|
||||
self.emit(Op::GetIndex);
|
||||
self.emit(Op::SetLocal(item_slot));
|
||||
self.emit(Op::Pop);
|
||||
|
||||
for st in body {
|
||||
self.compile_stmt(st)?;
|
||||
}
|
||||
|
||||
self.emit(Op::GetLocal(i_slot));
|
||||
let one = self.add_const(Value::Int(1));
|
||||
self.emit(Op::Constant(one));
|
||||
self.emit(Op::Add);
|
||||
self.emit(Op::SetLocal(i_slot));
|
||||
self.emit(Op::Pop);
|
||||
self.emit(Op::Jump(loop_start));
|
||||
self.patch(exit_j, Op::JumpIfFalse(self.here()));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn compile_call(&mut self, call: &CallExpr, as_stmt: bool) -> Result<()> {
|
||||
match call.callee.as_str() {
|
||||
"print" => {
|
||||
let text_expr = call
|
||||
.args
|
||||
.iter()
|
||||
.find_map(|a| match a {
|
||||
Arg::Named { name, value } if name == "text" => Some(value),
|
||||
_ => None,
|
||||
})
|
||||
.or_else(|| {
|
||||
call.args.iter().find_map(|a| match a {
|
||||
Arg::Positional(e) => Some(e),
|
||||
_ => None,
|
||||
})
|
||||
})
|
||||
.ok_or_else(|| anyhow::anyhow!("bytecode: print needs text"))?;
|
||||
self.compile_expr(text_expr)?;
|
||||
self.emit(Op::Print);
|
||||
if !as_stmt {
|
||||
self.emit(Op::None_);
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
"input" => bail!("bytecode: input not supported"),
|
||||
_ => {}
|
||||
}
|
||||
|
||||
let fid = self.resolve_call(&call.callee)?;
|
||||
let params = self.flat[fid].params.clone();
|
||||
let mut named: HashMap<String, &Expr> = HashMap::new();
|
||||
let mut positionals = Vec::new();
|
||||
for a in &call.args {
|
||||
match a {
|
||||
Arg::Positional(e) => positionals.push(e),
|
||||
Arg::Named { name, value } => {
|
||||
named.insert(name.clone(), value);
|
||||
}
|
||||
}
|
||||
}
|
||||
let mut pos_i = 0;
|
||||
for p in ¶ms {
|
||||
if let Some(e) = named.get(p) {
|
||||
self.compile_expr(e)?;
|
||||
} else if pos_i < positionals.len() {
|
||||
self.compile_expr(positionals[pos_i])?;
|
||||
pos_i += 1;
|
||||
} else {
|
||||
bail!("bytecode: missing argument for parameter `{p}`");
|
||||
}
|
||||
}
|
||||
if pos_i < positionals.len() {
|
||||
bail!("bytecode: too many positional arguments");
|
||||
}
|
||||
self.emit(Op::Call(fid as u16, params.len() as u8));
|
||||
if as_stmt {
|
||||
self.emit(Op::Pop);
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn compile_expr(&mut self, expr: &Expr) -> Result<()> {
|
||||
match expr {
|
||||
Expr::Literal(lit) => match lit {
|
||||
Literal::None => self.emit(Op::None_),
|
||||
Literal::Bool(true) => self.emit(Op::True),
|
||||
Literal::Bool(false) => self.emit(Op::False),
|
||||
Literal::Int(n) => {
|
||||
let i = self.add_const(Value::Int(*n));
|
||||
self.emit(Op::Constant(i));
|
||||
}
|
||||
Literal::Text(t) => {
|
||||
let i = self.add_const(Value::Text(t.clone()));
|
||||
self.emit(Op::Constant(i));
|
||||
}
|
||||
},
|
||||
Expr::Var(name) => {
|
||||
let slot = self
|
||||
.locals
|
||||
.get(name)
|
||||
.copied()
|
||||
.ok_or_else(|| anyhow::anyhow!("bytecode: undefined variable `{name}`"))?;
|
||||
self.emit(Op::GetLocal(slot));
|
||||
}
|
||||
Expr::Interp(parts) => {
|
||||
if parts.is_empty() {
|
||||
let i = self.add_const(Value::Text(String::new()));
|
||||
self.emit(Op::Constant(i));
|
||||
return Ok(());
|
||||
}
|
||||
for (idx, part) in parts.iter().enumerate() {
|
||||
match part {
|
||||
InterpPart::Lit(t) => {
|
||||
let i = self.add_const(Value::Text(t.clone()));
|
||||
self.emit(Op::Constant(i));
|
||||
}
|
||||
InterpPart::Var(n) => {
|
||||
let slot = self.locals.get(n).copied().ok_or_else(|| {
|
||||
anyhow::anyhow!("bytecode: undefined variable `{n}`")
|
||||
})?;
|
||||
self.emit(Op::GetLocal(slot));
|
||||
}
|
||||
}
|
||||
if idx > 0 {
|
||||
self.emit(Op::Add);
|
||||
}
|
||||
}
|
||||
}
|
||||
Expr::Unary { op, expr } => {
|
||||
self.compile_expr(expr)?;
|
||||
match op {
|
||||
UnaryOp::Not => self.emit(Op::Not),
|
||||
UnaryOp::Neg => self.emit(Op::Negate),
|
||||
}
|
||||
}
|
||||
Expr::Binary {
|
||||
op: BinaryOp::And,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
// JumpIfFalse always pops the tested value.
|
||||
self.compile_expr(left)?;
|
||||
let j_false = self.here();
|
||||
self.emit(Op::JumpIfFalse(0));
|
||||
self.compile_expr(right)?;
|
||||
let j_false2 = self.here();
|
||||
self.emit(Op::JumpIfFalse(0));
|
||||
self.emit(Op::True);
|
||||
let j_end = self.here();
|
||||
self.emit(Op::Jump(0));
|
||||
let f2 = self.here();
|
||||
self.patch(j_false2, Op::JumpIfFalse(f2));
|
||||
self.emit(Op::False);
|
||||
let j_end2 = self.here();
|
||||
self.emit(Op::Jump(0));
|
||||
let f1 = self.here();
|
||||
self.patch(j_false, Op::JumpIfFalse(f1));
|
||||
self.emit(Op::False);
|
||||
let end = self.here();
|
||||
self.patch(j_end, Op::Jump(end));
|
||||
self.patch(j_end2, Op::Jump(end));
|
||||
}
|
||||
Expr::Binary {
|
||||
op: BinaryOp::Or,
|
||||
left,
|
||||
right,
|
||||
} => {
|
||||
self.compile_expr(left)?;
|
||||
let j_else = self.here();
|
||||
self.emit(Op::JumpIfFalse(0));
|
||||
self.emit(Op::True);
|
||||
let j_end = self.here();
|
||||
self.emit(Op::Jump(0));
|
||||
let else_ip = self.here();
|
||||
self.patch(j_else, Op::JumpIfFalse(else_ip));
|
||||
self.compile_expr(right)?;
|
||||
let j_f = self.here();
|
||||
self.emit(Op::JumpIfFalse(0));
|
||||
self.emit(Op::True);
|
||||
let j_end2 = self.here();
|
||||
self.emit(Op::Jump(0));
|
||||
let f = self.here();
|
||||
self.patch(j_f, Op::JumpIfFalse(f));
|
||||
self.emit(Op::False);
|
||||
let end = self.here();
|
||||
self.patch(j_end, Op::Jump(end));
|
||||
self.patch(j_end2, Op::Jump(end));
|
||||
}
|
||||
Expr::Binary { op, left, right } => {
|
||||
self.compile_expr(left)?;
|
||||
self.compile_expr(right)?;
|
||||
self.emit(match op {
|
||||
BinaryOp::Add => Op::Add,
|
||||
BinaryOp::Sub => Op::Sub,
|
||||
BinaryOp::Mul => Op::Mul,
|
||||
BinaryOp::Div => Op::Div,
|
||||
BinaryOp::Eq => Op::Equal,
|
||||
BinaryOp::Ne => Op::NotEqual,
|
||||
BinaryOp::Lt => Op::Less,
|
||||
BinaryOp::Le => Op::Lessequal,
|
||||
BinaryOp::Gt => Op::Greater,
|
||||
BinaryOp::Ge => Op::GreaterEqual,
|
||||
BinaryOp::And | BinaryOp::Or => unreachable!(),
|
||||
});
|
||||
}
|
||||
Expr::Call(call) => self.compile_call(call, false)?,
|
||||
Expr::List(items) => {
|
||||
for it in items {
|
||||
self.compile_expr(it)?;
|
||||
}
|
||||
self.emit(Op::BuildList(items.len() as u16));
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,80 @@
|
||||
//! Bytecode chunk + opcodes (M5 prototype).
|
||||
|
||||
mod compile;
|
||||
mod vm;
|
||||
|
||||
pub use compile::compile_module;
|
||||
pub use vm::Vm;
|
||||
|
||||
use crate::value::Value;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub enum Op {
|
||||
Constant(u16),
|
||||
True,
|
||||
False,
|
||||
None_,
|
||||
Pop,
|
||||
GetLocal(u8),
|
||||
SetLocal(u8),
|
||||
Add,
|
||||
Sub,
|
||||
Mul,
|
||||
Div,
|
||||
Negate,
|
||||
Not,
|
||||
Equal,
|
||||
NotEqual,
|
||||
Greater,
|
||||
GreaterEqual,
|
||||
Less,
|
||||
Lessequal,
|
||||
/// Absolute jump to instruction index.
|
||||
Jump(u16),
|
||||
JumpIfFalse(u16),
|
||||
Print,
|
||||
BuildList(u16),
|
||||
Len,
|
||||
GetIndex,
|
||||
/// Call function by index; argc values are on the stack (param order).
|
||||
Call(u16, u8),
|
||||
Return,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct FnChunk {
|
||||
pub name: String,
|
||||
pub params: Vec<String>,
|
||||
pub code: Vec<Op>,
|
||||
pub constants: Vec<Value>,
|
||||
/// Local slot names (params first).
|
||||
pub locals: Vec<String>,
|
||||
}
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct Program {
|
||||
pub functions: Vec<FnChunk>,
|
||||
pub entry: usize,
|
||||
}
|
||||
|
||||
impl Program {
|
||||
pub fn disassemble(&self) -> String {
|
||||
let mut out = String::new();
|
||||
out.push_str("=== marqdo: bytecode ===\n");
|
||||
for (fi, fun) in self.functions.iter().enumerate() {
|
||||
let entry = if fi == self.entry { " <entry>" } else { "" };
|
||||
out.push_str(&format!(
|
||||
"fn[{fi}] {} params={:?} locals={:?}{entry}\n",
|
||||
fun.name, fun.params, fun.locals
|
||||
));
|
||||
for (i, c) in fun.constants.iter().enumerate() {
|
||||
out.push_str(&format!(" const[{i}] = {c:?}\n"));
|
||||
}
|
||||
for (ip, op) in fun.code.iter().enumerate() {
|
||||
out.push_str(&format!(" {ip:04} {op:?}\n"));
|
||||
}
|
||||
}
|
||||
out.push_str("=== marqdo: end bytecode ===\n");
|
||||
out
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,236 @@
|
||||
//! Stack VM for Marqdo bytecode.
|
||||
|
||||
use anyhow::{bail, Result};
|
||||
|
||||
use crate::bytecode::{Op, Program};
|
||||
use crate::value::Value;
|
||||
|
||||
pub struct Vm {
|
||||
capture: bool,
|
||||
pub captured_stdout: String,
|
||||
}
|
||||
|
||||
struct Frame {
|
||||
fn_idx: usize,
|
||||
ip: usize,
|
||||
slots: Vec<Value>,
|
||||
}
|
||||
|
||||
impl Vm {
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
capture: false,
|
||||
captured_stdout: String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn with_capture() -> Self {
|
||||
Self {
|
||||
capture: true,
|
||||
captured_stdout: String::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn emit_line(&mut self, text: &str) {
|
||||
if self.capture {
|
||||
self.captured_stdout.push_str(text);
|
||||
self.captured_stdout.push('\n');
|
||||
} else {
|
||||
println!("{text}");
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run(&mut self, program: &Program) -> Result<Value> {
|
||||
let mut stack: Vec<Value> = Vec::new();
|
||||
let entry = program.entry;
|
||||
let arity = program.functions[entry].params.len();
|
||||
if arity != 0 {
|
||||
bail!("bytecode: entry function needs arguments");
|
||||
}
|
||||
let mut frames = vec![Frame {
|
||||
fn_idx: entry,
|
||||
ip: 0,
|
||||
slots: vec![Value::None; program.functions[entry].locals.len().max(1)],
|
||||
}];
|
||||
|
||||
loop {
|
||||
let frame = frames.last_mut().unwrap();
|
||||
let fun = &program.functions[frame.fn_idx];
|
||||
if frame.ip >= fun.code.len() {
|
||||
bail!("bytecode: ip out of range in {}", fun.name);
|
||||
}
|
||||
let op = fun.code[frame.ip];
|
||||
frame.ip += 1;
|
||||
|
||||
match op {
|
||||
Op::Constant(i) => stack.push(fun.constants[i as usize].clone()),
|
||||
Op::True => stack.push(Value::Bool(true)),
|
||||
Op::False => stack.push(Value::Bool(false)),
|
||||
Op::None_ => stack.push(Value::None),
|
||||
Op::Pop => {
|
||||
stack.pop();
|
||||
}
|
||||
Op::GetLocal(i) => {
|
||||
let v = frames.last().unwrap().slots[i as usize].clone();
|
||||
stack.push(v);
|
||||
}
|
||||
Op::SetLocal(i) => {
|
||||
let v = stack.last().cloned().unwrap_or(Value::None);
|
||||
let slot = i as usize;
|
||||
let fr = frames.last_mut().unwrap();
|
||||
if fr.slots.len() <= slot {
|
||||
fr.slots.resize(slot + 1, Value::None);
|
||||
}
|
||||
fr.slots[slot] = v;
|
||||
}
|
||||
Op::Add => {
|
||||
let b = pop(&mut stack)?;
|
||||
let a = pop(&mut stack)?;
|
||||
stack.push(add(a, b)?);
|
||||
}
|
||||
Op::Sub => bin_int(&mut stack, |a, b| a - b)?,
|
||||
Op::Mul => bin_int(&mut stack, |a, b| a * b)?,
|
||||
Op::Div => {
|
||||
let b = pop(&mut stack)?;
|
||||
let a = pop(&mut stack)?;
|
||||
match (a, b) {
|
||||
(Value::Int(_), Value::Int(0)) => bail!("division by zero"),
|
||||
(Value::Int(x), Value::Int(y)) => stack.push(Value::Int(x / y)),
|
||||
_ => bail!("`/` needs ints"),
|
||||
}
|
||||
}
|
||||
Op::Negate => match pop(&mut stack)? {
|
||||
Value::Int(n) => stack.push(Value::Int(-n)),
|
||||
_ => bail!("unary `-` needs int"),
|
||||
},
|
||||
Op::Not => {
|
||||
let v = pop(&mut stack)?;
|
||||
stack.push(Value::Bool(!v.truthy()));
|
||||
}
|
||||
Op::Equal => {
|
||||
let b = pop(&mut stack)?;
|
||||
let a = pop(&mut stack)?;
|
||||
stack.push(Value::Bool(a == b));
|
||||
}
|
||||
Op::NotEqual => {
|
||||
let b = pop(&mut stack)?;
|
||||
let a = pop(&mut stack)?;
|
||||
stack.push(Value::Bool(a != b));
|
||||
}
|
||||
Op::Greater => cmp(&mut stack, |o| o.is_gt())?,
|
||||
Op::GreaterEqual => cmp(&mut stack, |o| o.is_ge())?,
|
||||
Op::Less => cmp(&mut stack, |o| o.is_lt())?,
|
||||
Op::Lessequal => cmp(&mut stack, |o| o.is_le())?,
|
||||
Op::Jump(t) => {
|
||||
frames.last_mut().unwrap().ip = t as usize;
|
||||
}
|
||||
Op::JumpIfFalse(t) => {
|
||||
let v = pop(&mut stack)?;
|
||||
if !v.truthy() {
|
||||
frames.last_mut().unwrap().ip = t as usize;
|
||||
}
|
||||
}
|
||||
Op::Print => {
|
||||
let v = pop(&mut stack)?;
|
||||
self.emit_line(&v.as_display());
|
||||
}
|
||||
Op::BuildList(n) => {
|
||||
let n = n as usize;
|
||||
let mut items = Vec::with_capacity(n);
|
||||
for _ in 0..n {
|
||||
items.push(pop(&mut stack)?);
|
||||
}
|
||||
items.reverse();
|
||||
stack.push(Value::List(items));
|
||||
}
|
||||
Op::Len => match pop(&mut stack)? {
|
||||
Value::List(xs) => stack.push(Value::Int(xs.len() as i64)),
|
||||
_ => bail!("len needs list"),
|
||||
},
|
||||
Op::GetIndex => {
|
||||
let idx = pop(&mut stack)?;
|
||||
let list = pop(&mut stack)?;
|
||||
match (list, idx) {
|
||||
(Value::List(xs), Value::Int(i)) if i >= 0 && (i as usize) < xs.len() => {
|
||||
stack.push(xs[i as usize].clone());
|
||||
}
|
||||
(Value::List(_), Value::Int(_)) => stack.push(Value::None),
|
||||
_ => bail!("GetIndex needs list and int"),
|
||||
}
|
||||
}
|
||||
Op::Call(fid, argc) => {
|
||||
let fid = fid as usize;
|
||||
let argc = argc as usize;
|
||||
let callee = &program.functions[fid];
|
||||
if callee.params.len() != argc {
|
||||
bail!("bytecode: call argc mismatch");
|
||||
}
|
||||
let mut slots = vec![Value::None; callee.locals.len().max(argc).max(1)];
|
||||
for i in (0..argc).rev() {
|
||||
slots[i] = pop(&mut stack)?;
|
||||
}
|
||||
// args were pushed in param order; we popped reverse so slots[0] is last param — fix:
|
||||
// stack had p0, p1, p2 (top). pop → p2, p1, p0. So assign slots[argc-1-i] or pop into reverse.
|
||||
// Actually we did: for i in (0..argc).rev() { slots[i] = pop() }
|
||||
// first pop → slots[argc-1] = top = last param. Good if push order was p0..plast.
|
||||
frames.push(Frame {
|
||||
fn_idx: fid,
|
||||
ip: 0,
|
||||
slots,
|
||||
});
|
||||
}
|
||||
Op::Return => {
|
||||
let ret = pop(&mut stack).unwrap_or(Value::None);
|
||||
frames.pop();
|
||||
if frames.is_empty() {
|
||||
return Ok(ret);
|
||||
}
|
||||
stack.push(ret);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn pop(stack: &mut Vec<Value>) -> Result<Value> {
|
||||
stack
|
||||
.pop()
|
||||
.ok_or_else(|| anyhow::anyhow!("bytecode: stack underflow"))
|
||||
}
|
||||
|
||||
fn add(a: Value, b: Value) -> Result<Value> {
|
||||
match (a, b) {
|
||||
(Value::Int(x), Value::Int(y)) => Ok(Value::Int(x + y)),
|
||||
(Value::Text(x), Value::Text(y)) => Ok(Value::Text(format!("{x}{y}"))),
|
||||
(Value::Text(x), y) => Ok(Value::Text(format!("{x}{}", y.as_display()))),
|
||||
(x, Value::Text(y)) => Ok(Value::Text(format!("{}{y}", x.as_display()))),
|
||||
// Int + display for interp GetLocal Int + Lit text
|
||||
(Value::Int(x), y) => Ok(Value::Text(format!("{}{}", x, y.as_display()))),
|
||||
(x, Value::Int(y)) => Ok(Value::Text(format!("{}{y}", x.as_display()))),
|
||||
_ => bail!("`+` needs ints or text"),
|
||||
}
|
||||
}
|
||||
|
||||
fn bin_int(stack: &mut Vec<Value>, f: impl Fn(i64, i64) -> i64) -> Result<()> {
|
||||
let b = pop(stack)?;
|
||||
let a = pop(stack)?;
|
||||
match (a, b) {
|
||||
(Value::Int(x), Value::Int(y)) => {
|
||||
stack.push(Value::Int(f(x, y)));
|
||||
Ok(())
|
||||
}
|
||||
_ => bail!("binary op needs ints"),
|
||||
}
|
||||
}
|
||||
|
||||
fn cmp(stack: &mut Vec<Value>, pred: impl Fn(std::cmp::Ordering) -> bool) -> Result<()> {
|
||||
let b = pop(stack)?;
|
||||
let a = pop(stack)?;
|
||||
let ord = match (&a, &b) {
|
||||
(Value::Int(x), Value::Int(y)) => x.cmp(y),
|
||||
(Value::Text(x), Value::Text(y)) => x.cmp(y),
|
||||
_ => bail!("comparison needs two ints or two texts"),
|
||||
};
|
||||
stack.push(Value::Bool(pred(ord)));
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,9 @@
|
||||
//! Captured program run (for tests and `view`).
|
||||
|
||||
use crate::value::Value;
|
||||
|
||||
#[derive(Debug, Clone)]
|
||||
pub struct RunCapture {
|
||||
pub stdout: String,
|
||||
pub value: Value,
|
||||
}
|
||||
+45
-2
@@ -1,16 +1,59 @@
|
||||
//! Diagnostics with file/line/column.
|
||||
//! Expanded in M1+.
|
||||
|
||||
use std::fmt;
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
#[derive(Debug, Clone, Copy)]
|
||||
use thiserror::Error;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct Span {
|
||||
pub line: u32,
|
||||
pub col: u32,
|
||||
}
|
||||
|
||||
impl Span {
|
||||
pub fn new(line: u32, col: u32) -> Self {
|
||||
Self { line, col }
|
||||
}
|
||||
}
|
||||
|
||||
impl fmt::Display for Span {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "{}:{}", self.line, self.col)
|
||||
}
|
||||
}
|
||||
|
||||
/// Unified diagnostic: `path:line:col: message` (path omitted if unknown).
|
||||
#[derive(Debug, Error, Clone)]
|
||||
#[error("{}", self.format_message())]
|
||||
pub struct Diagnostic {
|
||||
pub path: Option<PathBuf>,
|
||||
pub span: Span,
|
||||
pub message: String,
|
||||
}
|
||||
|
||||
impl Diagnostic {
|
||||
pub fn new(path: Option<&Path>, span: Span, message: impl Into<String>) -> Self {
|
||||
Self {
|
||||
path: path.map(|p| p.to_path_buf()),
|
||||
span,
|
||||
message: message.into(),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn at(path: &Path, span: Span, message: impl Into<String>) -> Self {
|
||||
Self::new(Some(path), span, message)
|
||||
}
|
||||
|
||||
pub fn format_message(&self) -> String {
|
||||
match &self.path {
|
||||
Some(p) => format!("{}:{}: {}", p.display(), self.span, self.message),
|
||||
None => format!("{}: {}", self.span, self.message),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Convenience for `anyhow` sites that already have a span.
|
||||
pub fn bail_at(path: Option<&Path>, span: Span, message: impl Into<String>) -> anyhow::Error {
|
||||
anyhow::Error::new(Diagnostic::new(path, span, message))
|
||||
}
|
||||
+149
-54
@@ -1,15 +1,21 @@
|
||||
//! Tree-walk interpreter (Phase I).
|
||||
|
||||
use anyhow::{bail, Result};
|
||||
use std::collections::HashMap;
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::path::{Path, PathBuf};
|
||||
|
||||
use crate::ast::{
|
||||
BinaryOp, CallExpr, Expr, Function, InterpPart, Literal, Module, Stmt, UnaryOp,
|
||||
Arg, BinaryOp, CallExpr, Expr, Function, InterpPart, Literal, Module, Stmt, UnaryOp,
|
||||
};
|
||||
use crate::diagnostics::{bail_at, Span};
|
||||
use crate::value::Value;
|
||||
|
||||
pub struct Interpreter {
|
||||
pub path: Option<PathBuf>,
|
||||
pub trace: bool,
|
||||
capture: bool,
|
||||
pub captured_stdout: String,
|
||||
current_span: Span,
|
||||
}
|
||||
|
||||
struct Env {
|
||||
@@ -32,16 +38,49 @@ impl Env {
|
||||
}
|
||||
}
|
||||
|
||||
enum EvArg {
|
||||
Positional(Value),
|
||||
Named(String, Value),
|
||||
}
|
||||
|
||||
impl Interpreter {
|
||||
pub fn new(trace: bool) -> Self {
|
||||
Self { trace }
|
||||
pub fn new(path: Option<&Path>, trace: bool) -> Self {
|
||||
Self {
|
||||
path: path.map(|p| p.to_path_buf()),
|
||||
trace,
|
||||
capture: false,
|
||||
captured_stdout: String::new(),
|
||||
current_span: Span::new(1, 1),
|
||||
}
|
||||
}
|
||||
|
||||
pub fn with_capture(path: Option<&Path>, trace: bool) -> Self {
|
||||
Self {
|
||||
path: path.map(|p| p.to_path_buf()),
|
||||
trace,
|
||||
capture: true,
|
||||
captured_stdout: String::new(),
|
||||
current_span: Span::new(1, 1),
|
||||
}
|
||||
}
|
||||
|
||||
fn err(&self, message: impl Into<String>) -> anyhow::Error {
|
||||
bail_at(self.path.as_deref(), self.current_span, message)
|
||||
}
|
||||
|
||||
fn emit_line(&mut self, text: &str) {
|
||||
if self.capture {
|
||||
self.captured_stdout.push_str(text);
|
||||
self.captured_stdout.push('\n');
|
||||
} else {
|
||||
println!("{text}");
|
||||
}
|
||||
}
|
||||
|
||||
pub fn run_module(&mut self, module: &Module) -> Result<Value> {
|
||||
if let Some(main) = find_top(module, "main") {
|
||||
return self.run_function(module, main, Env::new(), &[]);
|
||||
}
|
||||
// No main: run each level-1 function with empty args (hello-style demos).
|
||||
let tops: Vec<&Function> = module.functions.iter().filter(|f| f.level == 1).collect();
|
||||
if tops.is_empty() {
|
||||
bail!("no `# main` and no level-1 function to run");
|
||||
@@ -68,7 +107,6 @@ impl Interpreter {
|
||||
for (k, v) in args {
|
||||
env.set(k.clone(), v.clone());
|
||||
}
|
||||
// Bind missing params to None
|
||||
for p in &fun.params {
|
||||
if env.get(p).is_none() {
|
||||
env.set(p.clone(), Value::None);
|
||||
@@ -88,7 +126,6 @@ impl Interpreter {
|
||||
Ok(ret)
|
||||
}
|
||||
|
||||
/// Returns Some if function should return.
|
||||
fn exec_stmt(
|
||||
&mut self,
|
||||
module: &Module,
|
||||
@@ -98,6 +135,7 @@ impl Interpreter {
|
||||
) -> Result<Option<Value>> {
|
||||
match stmt {
|
||||
Stmt::Assign { name, value, span } => {
|
||||
self.current_span = *span;
|
||||
let v = self.eval_expr(module, fun, env, value)?;
|
||||
if self.trace {
|
||||
eprintln!(" assign {name} = {v:?} @{span}");
|
||||
@@ -106,6 +144,7 @@ impl Interpreter {
|
||||
Ok(None)
|
||||
}
|
||||
Stmt::Return { value, span } => {
|
||||
self.current_span = *span;
|
||||
let v = self.eval_expr(module, fun, env, value)?;
|
||||
if self.trace {
|
||||
eprintln!(" return {v:?} @{span}");
|
||||
@@ -113,6 +152,7 @@ impl Interpreter {
|
||||
Ok(Some(v))
|
||||
}
|
||||
Stmt::Call { call, span } => {
|
||||
self.current_span = *span;
|
||||
if self.trace {
|
||||
eprintln!(" call-stmt {} @{span}", call.callee);
|
||||
}
|
||||
@@ -120,6 +160,7 @@ impl Interpreter {
|
||||
Ok(None)
|
||||
}
|
||||
Stmt::Branch { arms, span } => {
|
||||
self.current_span = *span;
|
||||
if self.trace {
|
||||
eprintln!(" branch @{span}");
|
||||
}
|
||||
@@ -144,15 +185,15 @@ impl Interpreter {
|
||||
body,
|
||||
span,
|
||||
} => {
|
||||
self.current_span = *span;
|
||||
if self.trace {
|
||||
eprintln!(" while @{span}");
|
||||
}
|
||||
// Guard against infinite loops in buggy programs.
|
||||
let mut guard = 0u32;
|
||||
while self.eval_expr(module, fun, env, condition)?.truthy() {
|
||||
guard += 1;
|
||||
if guard > 1_000_000 {
|
||||
bail!("{span}: while loop exceeded iteration limit");
|
||||
return Err(self.err("while loop exceeded iteration limit"));
|
||||
}
|
||||
for s in body {
|
||||
if let Some(v) = self.exec_stmt(module, fun, env, s)? {
|
||||
@@ -168,16 +209,18 @@ impl Interpreter {
|
||||
body,
|
||||
span,
|
||||
} => {
|
||||
self.current_span = *span;
|
||||
if self.trace {
|
||||
eprintln!(" foreach {item} in {collection} @{span}");
|
||||
}
|
||||
let coll = env
|
||||
.get(collection)
|
||||
.cloned()
|
||||
.ok_or_else(|| anyhow::anyhow!("{span}: undefined collection `{collection}`"))?;
|
||||
let coll = env.get(collection).cloned().ok_or_else(|| {
|
||||
self.err(format!("undefined collection `{collection}`"))
|
||||
})?;
|
||||
let items = match coll {
|
||||
Value::List(xs) => xs,
|
||||
other => bail!("{span}: foreach needs a list, got {other:?}"),
|
||||
other => {
|
||||
return Err(self.err(format!("foreach needs a list, got {other:?}")));
|
||||
}
|
||||
};
|
||||
for val in items {
|
||||
env.set(item.clone(), val);
|
||||
@@ -204,7 +247,7 @@ impl Interpreter {
|
||||
Expr::Var(name) => env
|
||||
.get(name)
|
||||
.cloned()
|
||||
.ok_or_else(|| anyhow::anyhow!("undefined variable `{name}`")),
|
||||
.ok_or_else(|| self.err(format!("undefined variable `{name}`"))),
|
||||
Expr::Interp(parts) => {
|
||||
let mut s = String::new();
|
||||
for part in parts {
|
||||
@@ -213,7 +256,7 @@ impl Interpreter {
|
||||
InterpPart::Var(n) => {
|
||||
let v = env
|
||||
.get(n)
|
||||
.ok_or_else(|| anyhow::anyhow!("undefined variable `{n}`"))?;
|
||||
.ok_or_else(|| self.err(format!("undefined variable `{n}`")))?;
|
||||
s.push_str(&v.as_display());
|
||||
}
|
||||
}
|
||||
@@ -226,13 +269,12 @@ impl Interpreter {
|
||||
UnaryOp::Not => Ok(Value::Bool(!v.truthy())),
|
||||
UnaryOp::Neg => match v {
|
||||
Value::Int(n) => Ok(Value::Int(-n)),
|
||||
_ => bail!("unary `-` needs int"),
|
||||
_ => Err(self.err("unary `-` needs int")),
|
||||
},
|
||||
}
|
||||
}
|
||||
Expr::Binary { op, left, right } => {
|
||||
let l = self.eval_expr(module, fun, env, left)?;
|
||||
// Short-circuit and/or
|
||||
match op {
|
||||
BinaryOp::And => {
|
||||
if !l.truthy() {
|
||||
@@ -251,7 +293,7 @@ impl Interpreter {
|
||||
_ => {}
|
||||
}
|
||||
let r = self.eval_expr(module, fun, env, right)?;
|
||||
eval_binary(*op, &l, &r)
|
||||
eval_binary(*op, &l, &r).map_err(|e| self.err(e.to_string()))
|
||||
}
|
||||
Expr::Call(call) => self.eval_call(module, fun, env, call),
|
||||
Expr::List(items) => {
|
||||
@@ -271,26 +313,41 @@ impl Interpreter {
|
||||
env: &mut Env,
|
||||
call: &CallExpr,
|
||||
) -> Result<Value> {
|
||||
let mut arg_vals = Vec::new();
|
||||
for (k, e) in &call.args {
|
||||
arg_vals.push((k.clone(), self.eval_expr(module, fun, env, e)?));
|
||||
let mut ev_args = Vec::new();
|
||||
for arg in &call.args {
|
||||
match arg {
|
||||
Arg::Positional(e) => {
|
||||
ev_args.push(EvArg::Positional(self.eval_expr(module, fun, env, e)?));
|
||||
}
|
||||
Arg::Named { name, value } => {
|
||||
ev_args.push(EvArg::Named(
|
||||
name.clone(),
|
||||
self.eval_expr(module, fun, env, value)?,
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
match call.callee.as_str() {
|
||||
"print" => {
|
||||
let text = arg_vals
|
||||
.iter()
|
||||
.find(|(k, _)| k == "text")
|
||||
.map(|(_, v)| v.as_display())
|
||||
.ok_or_else(|| anyhow::anyhow!("print requires text=..."))?;
|
||||
println!("{text}");
|
||||
let bound = bind_args(&["text".into()], &ev_args, false)
|
||||
.map_err(|m| self.err(m))?;
|
||||
let text = bound
|
||||
.get("text")
|
||||
.map(|v| v.as_display())
|
||||
.ok_or_else(|| self.err("print requires text (named or positional)"))?;
|
||||
self.emit_line(&text);
|
||||
return Ok(Value::None);
|
||||
}
|
||||
"input" => {
|
||||
let prompt = arg_vals
|
||||
.iter()
|
||||
.find(|(k, _)| k == "prompt")
|
||||
.map(|(_, v)| v.as_display())
|
||||
if self.capture {
|
||||
return Err(self.err("input is not available under capture / view"));
|
||||
}
|
||||
let bound = bind_args(&["prompt".into()], &ev_args, true)
|
||||
.map_err(|m| self.err(m))?;
|
||||
let prompt = bound
|
||||
.get("prompt")
|
||||
.map(|v| v.as_display())
|
||||
.unwrap_or_default();
|
||||
if !prompt.is_empty() {
|
||||
print!("{prompt}");
|
||||
@@ -310,27 +367,71 @@ impl Interpreter {
|
||||
_ => {}
|
||||
}
|
||||
|
||||
let target = lookup_function(module, fun, &call.callee).ok_or_else(|| {
|
||||
anyhow::anyhow!("unknown function `{}`", call.callee)
|
||||
})?;
|
||||
let target = lookup_function(module, fun, &call.callee)
|
||||
.ok_or_else(|| self.err(format!("unknown function `{}`", call.callee)))?;
|
||||
|
||||
// Bind by param names: prefer named args matching params; also allow arg keys as env names.
|
||||
let bound = bind_args(&target.params, &ev_args, false).map_err(|m| self.err(m))?;
|
||||
let mut call_env = Env::new();
|
||||
for p in &target.params {
|
||||
if let Some((_, v)) = arg_vals.iter().find(|(k, _)| k == p) {
|
||||
call_env.set(p.clone(), v.clone());
|
||||
}
|
||||
}
|
||||
for (k, v) in &arg_vals {
|
||||
if call_env.get(k).is_none() {
|
||||
call_env.set(k.clone(), v.clone());
|
||||
}
|
||||
for (k, v) in bound {
|
||||
call_env.set(k, v);
|
||||
}
|
||||
|
||||
self.run_function(module, target, call_env, &[])
|
||||
}
|
||||
}
|
||||
|
||||
/// Bind evaluated args onto parameter names. Err is a plain message (caller adds span/path).
|
||||
fn bind_args(
|
||||
params: &[String],
|
||||
args: &[EvArg],
|
||||
allow_missing: bool,
|
||||
) -> std::result::Result<HashMap<String, Value>, String> {
|
||||
let mut named: HashMap<String, Value> = HashMap::new();
|
||||
let mut positionals = Vec::new();
|
||||
for a in args {
|
||||
match a {
|
||||
EvArg::Positional(v) => positionals.push(v.clone()),
|
||||
EvArg::Named(k, v) => {
|
||||
if named.contains_key(k) {
|
||||
return Err(format!("duplicate named argument `{k}`"));
|
||||
}
|
||||
named.insert(k.clone(), v.clone());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let mut out: HashMap<String, Value> = HashMap::new();
|
||||
let mut used_named = HashSet::new();
|
||||
let mut pos_i = 0usize;
|
||||
|
||||
for p in params {
|
||||
if let Some(v) = named.get(p) {
|
||||
out.insert(p.clone(), v.clone());
|
||||
used_named.insert(p.clone());
|
||||
} else if pos_i < positionals.len() {
|
||||
out.insert(p.clone(), positionals[pos_i].clone());
|
||||
pos_i += 1;
|
||||
} else if !allow_missing {
|
||||
return Err(format!("missing argument for parameter `{p}`"));
|
||||
}
|
||||
}
|
||||
|
||||
if pos_i < positionals.len() {
|
||||
return Err(format!(
|
||||
"too many positional arguments ({} extra)",
|
||||
positionals.len() - pos_i
|
||||
));
|
||||
}
|
||||
|
||||
for (k, v) in named {
|
||||
if !used_named.contains(&k) && !out.contains_key(&k) {
|
||||
out.insert(k, v);
|
||||
}
|
||||
}
|
||||
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
fn find_top<'a>(module: &'a Module, name: &str) -> Option<&'a Function> {
|
||||
module.functions.iter().find(|f| f.name == name)
|
||||
}
|
||||
@@ -340,11 +441,9 @@ fn lookup_function<'a>(
|
||||
current: &'a Function,
|
||||
name: &str,
|
||||
) -> Option<&'a Function> {
|
||||
// Nested children of current (hoisted).
|
||||
if let Some(f) = find_in_tree(current, name) {
|
||||
return Some(f);
|
||||
}
|
||||
// Top-level / imported.
|
||||
module.functions.iter().find(|f| f.name == name)
|
||||
}
|
||||
|
||||
@@ -376,7 +475,7 @@ fn eval_binary(op: BinaryOp, l: &Value, r: &Value) -> Result<Value> {
|
||||
(Value::Text(a), Value::Text(b)) => Ok(Value::Text(format!("{a}{b}"))),
|
||||
(Value::Text(a), b) => Ok(Value::Text(format!("{a}{}", b.as_display()))),
|
||||
(a, Value::Text(b)) => Ok(Value::Text(format!("{}{b}", a.as_display()))),
|
||||
_ => bail!("`+` needs ints or text, got {l:?} and {r:?}"),
|
||||
_ => bail!("`+` needs ints or text"),
|
||||
},
|
||||
BinaryOp::Sub => match (l, r) {
|
||||
(Value::Int(a), Value::Int(b)) => Ok(Value::Int(a - b)),
|
||||
@@ -391,8 +490,8 @@ fn eval_binary(op: BinaryOp, l: &Value, r: &Value) -> Result<Value> {
|
||||
(Value::Int(a), Value::Int(b)) => Ok(Value::Int(a / b)),
|
||||
_ => bail!("`/` needs ints"),
|
||||
},
|
||||
BinaryOp::Eq => Ok(Value::Bool(values_eq(l, r))),
|
||||
BinaryOp::Ne => Ok(Value::Bool(!values_eq(l, r))),
|
||||
BinaryOp::Eq => Ok(Value::Bool(l == r)),
|
||||
BinaryOp::Ne => Ok(Value::Bool(l != r)),
|
||||
BinaryOp::Lt => cmp_ord(l, r, |o| o.is_lt()),
|
||||
BinaryOp::Le => cmp_ord(l, r, |o| o.is_le()),
|
||||
BinaryOp::Gt => cmp_ord(l, r, |o| o.is_gt()),
|
||||
@@ -401,10 +500,6 @@ fn eval_binary(op: BinaryOp, l: &Value, r: &Value) -> Result<Value> {
|
||||
}
|
||||
}
|
||||
|
||||
fn values_eq(l: &Value, r: &Value) -> bool {
|
||||
l == r
|
||||
}
|
||||
|
||||
fn cmp_ord(l: &Value, r: &Value, f: impl Fn(std::cmp::Ordering) -> bool) -> Result<Value> {
|
||||
match (l, r) {
|
||||
(Value::Int(a), Value::Int(b)) => Ok(Value::Bool(f(a.cmp(b)))),
|
||||
|
||||
+1
-1
@@ -122,7 +122,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn classify_hello_fixture() {
|
||||
let src = include_str!("../../examples/hello.mq.md");
|
||||
let src = include_str!("../../examples/structure/hello.mq.md");
|
||||
let lines = classify_source(src);
|
||||
assert!(lines.iter().any(|l| l.kind == LineKind::Code && l.text.contains("print")));
|
||||
assert!(lines.iter().any(|l| l.kind == LineKind::Comment));
|
||||
|
||||
+85
-10
@@ -1,8 +1,11 @@
|
||||
//! Marqdo reference interpreter (Phase I).
|
||||
//! Marqdo reference interpreter (Phase I + M5 bytecode prototype).
|
||||
//!
|
||||
//! Pipeline: load → line classify → parse → tree-walk eval.
|
||||
//! Pipeline: load → line classify → parse → tree-walk eval | bytecode VM.
|
||||
//! CLI also offers `view` for AST-backed browsing.
|
||||
|
||||
pub mod ast;
|
||||
pub mod bytecode;
|
||||
pub mod capture;
|
||||
pub mod debug;
|
||||
pub mod diagnostics;
|
||||
pub mod interp;
|
||||
@@ -10,16 +13,36 @@ pub mod lex;
|
||||
pub mod load;
|
||||
pub mod parse;
|
||||
pub mod value;
|
||||
pub mod view;
|
||||
|
||||
use std::path::Path;
|
||||
|
||||
use anyhow::{bail, Result};
|
||||
|
||||
use crate::ast::format_ast_dump;
|
||||
use crate::bytecode::{compile_module, Vm};
|
||||
use crate::capture::RunCapture;
|
||||
use crate::interp::Interpreter;
|
||||
use crate::lex::{classify_source, format_lines_dump};
|
||||
use crate::load::load_module;
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
|
||||
pub enum Backend {
|
||||
#[default]
|
||||
Tree,
|
||||
Bytecode,
|
||||
}
|
||||
|
||||
impl Backend {
|
||||
pub fn parse(s: &str) -> Result<Self> {
|
||||
match s {
|
||||
"tree" => Ok(Self::Tree),
|
||||
"bytecode" | "bc" => Ok(Self::Bytecode),
|
||||
other => bail!("unknown backend `{other}` (expected tree|bytecode)"),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Options for a single `run` / dump invocation.
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct RunOptions {
|
||||
@@ -27,7 +50,9 @@ pub struct RunOptions {
|
||||
pub dump_tokens: bool,
|
||||
pub dump_ast: bool,
|
||||
pub dump_sema: bool,
|
||||
pub dump_bytecode: bool,
|
||||
pub trace_eval: bool,
|
||||
pub backend: Backend,
|
||||
}
|
||||
|
||||
impl RunOptions {
|
||||
@@ -37,16 +62,23 @@ impl RunOptions {
|
||||
dump_tokens: true,
|
||||
dump_ast: true,
|
||||
dump_sema: true,
|
||||
dump_bytecode: true,
|
||||
trace_eval: true,
|
||||
backend: Backend::Tree,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn any_dump(&self) -> bool {
|
||||
self.dump_lines || self.dump_tokens || self.dump_ast || self.dump_sema || self.trace_eval
|
||||
self.dump_lines
|
||||
|| self.dump_tokens
|
||||
|| self.dump_ast
|
||||
|| self.dump_sema
|
||||
|| self.dump_bytecode
|
||||
|| self.trace_eval
|
||||
}
|
||||
}
|
||||
|
||||
/// Run a `.mq.md` program.
|
||||
/// Run a `.mq.md` program (prints to real stdout).
|
||||
pub fn run_file(path: &Path, opts: &RunOptions) -> Result<i32> {
|
||||
let source = std::fs::read_to_string(path)
|
||||
.map_err(|e| anyhow::anyhow!("failed to read {}: {e}", path.display()))?;
|
||||
@@ -86,13 +118,56 @@ pub fn run_file(path: &Path, opts: &RunOptions) -> Result<i32> {
|
||||
println!("=== marqdo: end sema ===");
|
||||
}
|
||||
|
||||
let mut interp = Interpreter::new(opts.trace_eval);
|
||||
if opts.trace_eval {
|
||||
eprintln!("=== marqdo: trace-eval ({path_label}) ===");
|
||||
match opts.backend {
|
||||
Backend::Tree => {
|
||||
let mut interp = Interpreter::new(Some(path), opts.trace_eval);
|
||||
if opts.trace_eval {
|
||||
eprintln!("=== marqdo: trace-eval ({path_label}) ===");
|
||||
}
|
||||
interp.run_module(&module)?;
|
||||
if opts.trace_eval {
|
||||
eprintln!("=== marqdo: end trace-eval ===");
|
||||
}
|
||||
}
|
||||
Backend::Bytecode => {
|
||||
let program = compile_module(&module)?;
|
||||
if opts.dump_bytecode {
|
||||
print!("{}", program.disassemble());
|
||||
}
|
||||
let mut vm = Vm::new();
|
||||
vm.run(&program)?;
|
||||
}
|
||||
}
|
||||
interp.run_module(&module)?;
|
||||
if opts.trace_eval {
|
||||
eprintln!("=== marqdo: end trace-eval ===");
|
||||
|
||||
// dump bytecode even on tree backend if requested
|
||||
if opts.backend == Backend::Tree && opts.dump_bytecode {
|
||||
let program = compile_module(&module)?;
|
||||
print!("{}", program.disassemble());
|
||||
}
|
||||
|
||||
Ok(0)
|
||||
}
|
||||
|
||||
/// Run and capture stdout (used by `view` and tests).
|
||||
pub fn run_file_capture(path: &Path, opts: &RunOptions) -> Result<RunCapture> {
|
||||
let module = load_module(path)?;
|
||||
match opts.backend {
|
||||
Backend::Tree => {
|
||||
let mut interp = Interpreter::with_capture(Some(path), false);
|
||||
let value = interp.run_module(&module)?;
|
||||
Ok(RunCapture {
|
||||
stdout: interp.captured_stdout,
|
||||
value,
|
||||
})
|
||||
}
|
||||
Backend::Bytecode => {
|
||||
let program = compile_module(&module)?;
|
||||
let mut vm = Vm::with_capture();
|
||||
let value = vm.run(&program)?;
|
||||
Ok(RunCapture {
|
||||
stdout: vm.captured_stdout,
|
||||
value,
|
||||
})
|
||||
}
|
||||
}
|
||||
}
|
||||
+21
-4
@@ -6,6 +6,7 @@ use std::path::{Path, PathBuf};
|
||||
use anyhow::{bail, Context, Result};
|
||||
|
||||
use crate::ast::{Function, Module};
|
||||
use crate::diagnostics::Diagnostic;
|
||||
use crate::parse::parse_source;
|
||||
|
||||
/// Load `path` and recursively merge imported modules' top-level functions.
|
||||
@@ -24,15 +25,13 @@ fn load_module_inner(path: &Path, visited: &mut HashSet<PathBuf>) -> Result<Modu
|
||||
|
||||
let source = std::fs::read_to_string(path)
|
||||
.with_context(|| format!("failed to read {}", path.display()))?;
|
||||
let mut module = parse_source(&source)
|
||||
.with_context(|| format!("parse error in {}", path.display()))?;
|
||||
let mut module = parse_source(&source).map_err(|e| attach_path(path, e))?;
|
||||
|
||||
let base = path.parent().unwrap_or_else(|| Path::new("."));
|
||||
let imports = module.imports.clone();
|
||||
for rel in imports {
|
||||
let dep_path = base.join(&rel);
|
||||
let dep = load_module_inner(&dep_path, visited)?;
|
||||
// Merge imported top-level functions (public API of the file).
|
||||
for fun in dep.functions {
|
||||
merge_top_level(&mut module.functions, fun);
|
||||
}
|
||||
@@ -41,9 +40,27 @@ fn load_module_inner(path: &Path, visited: &mut HashSet<PathBuf>) -> Result<Modu
|
||||
Ok(module)
|
||||
}
|
||||
|
||||
fn attach_path(path: &Path, err: anyhow::Error) -> anyhow::Error {
|
||||
if let Some(d) = err.downcast_ref::<Diagnostic>() {
|
||||
if d.path.is_none() {
|
||||
return Diagnostic::at(path, d.span, d.message.clone()).into();
|
||||
}
|
||||
return err;
|
||||
}
|
||||
// Legacy `line:col: message` from parse bail!
|
||||
let msg = err.to_string();
|
||||
if let Some((loc, rest)) = msg.split_once(": ") {
|
||||
if let Some((line_s, col_s)) = loc.split_once(':') {
|
||||
if let (Ok(line), Ok(col)) = (line_s.parse::<u32>(), col_s.parse::<u32>()) {
|
||||
return Diagnostic::at(path, crate::diagnostics::Span::new(line, col), rest).into();
|
||||
}
|
||||
}
|
||||
}
|
||||
err.context(format!("in {}", path.display()))
|
||||
}
|
||||
|
||||
fn merge_top_level(into: &mut Vec<Function>, fun: Function) {
|
||||
if let Some(existing) = into.iter_mut().find(|f| f.name == fun.name) {
|
||||
// Later definition wins (entry file overrides import).
|
||||
*existing = fun;
|
||||
} else {
|
||||
into.push(fun);
|
||||
|
||||
+58
-22
@@ -2,49 +2,72 @@ use std::path::PathBuf;
|
||||
use std::process::ExitCode;
|
||||
|
||||
use anyhow::Result;
|
||||
use clap::{Parser, Subcommand};
|
||||
use clap::{Parser, Subcommand, ValueEnum};
|
||||
|
||||
use marqdo::RunOptions;
|
||||
use marqdo::view::{serve, ViewOptions};
|
||||
use marqdo::{Backend, RunOptions};
|
||||
|
||||
#[derive(Parser, Debug)]
|
||||
#[command(name = "marqdo", version, about = "Marqdo interpreter — run .mq.md programs")]
|
||||
#[command(name = "marqdo", version, about = "Marqdo interpreter — run and view .mq.md programs")]
|
||||
struct Cli {
|
||||
#[command(subcommand)]
|
||||
command: Commands,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, ValueEnum)]
|
||||
enum BackendCli {
|
||||
Tree,
|
||||
Bytecode,
|
||||
}
|
||||
|
||||
impl From<BackendCli> for Backend {
|
||||
fn from(b: BackendCli) -> Self {
|
||||
match b {
|
||||
BackendCli::Tree => Backend::Tree,
|
||||
BackendCli::Bytecode => Backend::Bytecode,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Subcommand, Debug)]
|
||||
enum Commands {
|
||||
/// Execute a Marqdo source file (defaults to ./index.mq.md)
|
||||
Run {
|
||||
/// Path to a `.mq.md` file
|
||||
#[arg(value_name = "FILE")]
|
||||
file: Option<PathBuf>,
|
||||
|
||||
/// Dump line classification
|
||||
#[arg(long, value_enum, default_value_t = BackendCli::Tree)]
|
||||
backend: BackendCli,
|
||||
|
||||
#[arg(long)]
|
||||
dump_lines: bool,
|
||||
|
||||
/// Dump tokens (placeholder until lexer fills in)
|
||||
#[arg(long)]
|
||||
dump_tokens: bool,
|
||||
|
||||
/// Dump AST (placeholder until parser exists)
|
||||
#[arg(long)]
|
||||
dump_ast: bool,
|
||||
|
||||
/// Dump semantic info (placeholder)
|
||||
#[arg(long)]
|
||||
dump_sema: bool,
|
||||
|
||||
/// Trace evaluation (placeholder)
|
||||
#[arg(long)]
|
||||
dump_bytecode: bool,
|
||||
#[arg(long)]
|
||||
trace_eval: bool,
|
||||
|
||||
/// Enable all dumps
|
||||
#[arg(long)]
|
||||
dump_all: bool,
|
||||
},
|
||||
/// Browse `.mq.md` structure + execution in a local webpage
|
||||
View {
|
||||
#[arg(value_name = "PATH")]
|
||||
path: Option<PathBuf>,
|
||||
|
||||
#[arg(long, default_value = "127.0.0.1")]
|
||||
host: String,
|
||||
|
||||
#[arg(long, default_value_t = 7429)]
|
||||
port: u16,
|
||||
|
||||
#[arg(long)]
|
||||
no_open: bool,
|
||||
},
|
||||
}
|
||||
|
||||
fn main() -> ExitCode {
|
||||
@@ -62,10 +85,12 @@ fn try_main() -> Result<i32> {
|
||||
match cli.command {
|
||||
Commands::Run {
|
||||
file,
|
||||
backend,
|
||||
dump_lines,
|
||||
dump_tokens,
|
||||
dump_ast,
|
||||
dump_sema,
|
||||
dump_bytecode,
|
||||
trace_eval,
|
||||
dump_all,
|
||||
} => {
|
||||
@@ -78,19 +103,30 @@ fn try_main() -> Result<i32> {
|
||||
dump_tokens,
|
||||
dump_ast,
|
||||
dump_sema,
|
||||
dump_bytecode,
|
||||
trace_eval,
|
||||
backend: backend.into(),
|
||||
}
|
||||
};
|
||||
// dump_all already set; individual flags merge if not dump_all
|
||||
if !dump_all {
|
||||
opts.dump_lines = dump_lines;
|
||||
opts.dump_tokens = dump_tokens;
|
||||
opts.dump_ast = dump_ast;
|
||||
opts.dump_sema = dump_sema;
|
||||
opts.trace_eval = trace_eval;
|
||||
if dump_all {
|
||||
opts.backend = backend.into();
|
||||
}
|
||||
marqdo::run_file(&path, &opts)?;
|
||||
Ok(0)
|
||||
}
|
||||
Commands::View {
|
||||
path,
|
||||
host,
|
||||
port,
|
||||
no_open,
|
||||
} => {
|
||||
serve(ViewOptions {
|
||||
path: path.unwrap_or_else(|| PathBuf::from(".")),
|
||||
host,
|
||||
port,
|
||||
open_browser: !no_open,
|
||||
})?;
|
||||
Ok(0)
|
||||
}
|
||||
}
|
||||
}
|
||||
+93
-25
@@ -15,17 +15,41 @@ pub fn parse_expr(input: &str) -> Result<Expr> {
|
||||
}
|
||||
|
||||
/// Argument / template RHS: prefer a full expression; else interpolated text.
|
||||
/// Hyphenated prose (`none-falsy`) is not parsed as subtraction.
|
||||
pub fn parse_value_or_interp(input: &str) -> Result<Expr> {
|
||||
let s = input.trim();
|
||||
if s.is_empty() {
|
||||
return Ok(Expr::Literal(Literal::Text(String::new())));
|
||||
}
|
||||
if has_hyphenated_prose(s) {
|
||||
return Ok(parse_interp(s));
|
||||
}
|
||||
match parse_expr(s) {
|
||||
Ok(e) => Ok(e),
|
||||
Err(_) => Ok(parse_interp(s)),
|
||||
}
|
||||
}
|
||||
|
||||
fn has_hyphenated_prose(s: &str) -> bool {
|
||||
let chars: Vec<char> = s.chars().collect();
|
||||
for i in 1..chars.len().saturating_sub(1) {
|
||||
if chars[i] != '-' {
|
||||
continue;
|
||||
}
|
||||
let left = chars[i - 1];
|
||||
let right = chars[i + 1];
|
||||
if left.is_whitespace() || right.is_whitespace() || left == '`' || right == '`' {
|
||||
continue;
|
||||
}
|
||||
// `none-falsy` / `Hello-World` — not `` `n` - 1 ``
|
||||
if left.is_alphanumeric() || right.is_alphanumeric() || !left.is_ascii() || !right.is_ascii()
|
||||
{
|
||||
return true;
|
||||
}
|
||||
}
|
||||
false
|
||||
}
|
||||
|
||||
pub fn parse_interp(s: &str) -> Expr {
|
||||
let mut parts = Vec::new();
|
||||
let mut rest = s;
|
||||
@@ -329,18 +353,20 @@ fn is_word_end(s: &str, len: usize) -> bool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Parse `name key=val key2=val2` from a string; returns call + bytes consumed.
|
||||
/// Parse `name key=val …` / positional args; returns call + bytes consumed.
|
||||
pub fn parse_call_tail(s: &str) -> Result<(CallExpr, usize)> {
|
||||
let s = s.trim_start();
|
||||
let trimmed_lead = s.len(); // not used — work on s
|
||||
let _ = trimmed_lead;
|
||||
let original_len = s.len(); // we'll compute from full — caller passes rest after >
|
||||
use crate::ast::Arg;
|
||||
|
||||
let mut parts = s.split_whitespace();
|
||||
let callee = parts
|
||||
.next()
|
||||
.ok_or_else(|| anyhow::anyhow!("missing callee"))?
|
||||
.to_string();
|
||||
let s = s.trim_start();
|
||||
let original_len = s.len();
|
||||
|
||||
let callee = {
|
||||
let mut parts = s.split_whitespace();
|
||||
parts
|
||||
.next()
|
||||
.ok_or_else(|| anyhow::anyhow!("missing callee"))?
|
||||
.to_string()
|
||||
};
|
||||
|
||||
let after_callee_offset = {
|
||||
let idx = s.find(&callee).unwrap();
|
||||
@@ -348,26 +374,68 @@ pub fn parse_call_tail(s: &str) -> Result<(CallExpr, usize)> {
|
||||
};
|
||||
let mut args_str = s[after_callee_offset..].trim_start();
|
||||
let mut args = Vec::new();
|
||||
let mut seen_named = false;
|
||||
|
||||
// Support one or more `key=value`; value may contain spaces until next ` key=` pattern.
|
||||
while !args_str.is_empty() {
|
||||
let eq = args_str
|
||||
.find('=')
|
||||
.ok_or_else(|| anyhow::anyhow!("expected key=value in call args, got {args_str:?}"))?;
|
||||
let key = args_str[..eq].trim().to_string();
|
||||
if key.is_empty() {
|
||||
bail!("empty argument name");
|
||||
if let Some((key, after_eq)) = try_named_arg(args_str) {
|
||||
seen_named = true;
|
||||
let val_end = find_next_arg_boundary(after_eq);
|
||||
let val_raw = after_eq[..val_end].trim_end();
|
||||
args.push(Arg::Named {
|
||||
name: key,
|
||||
value: parse_value_or_interp(val_raw)?,
|
||||
});
|
||||
args_str = after_eq[val_end..].trim_start();
|
||||
} else {
|
||||
if seen_named {
|
||||
bail!("positional argument after named argument is not allowed");
|
||||
}
|
||||
let (tok, rest) = split_first_token(args_str);
|
||||
if tok.is_empty() {
|
||||
break;
|
||||
}
|
||||
args.push(Arg::Positional(parse_value_or_interp(tok)?));
|
||||
args_str = rest.trim_start();
|
||||
}
|
||||
let after_eq = &args_str[eq + 1..];
|
||||
// Value runs until ` word=` where word is next key, or end.
|
||||
let val_end = find_next_arg_boundary(after_eq);
|
||||
let val_raw = after_eq[..val_end].trim_end();
|
||||
args.push((key, parse_value_or_interp(val_raw)?));
|
||||
args_str = after_eq[val_end..].trim_start();
|
||||
}
|
||||
|
||||
let consumed = original_len; // entire rest consumed for stmt-form calls
|
||||
Ok((CallExpr { callee, args }, consumed))
|
||||
Ok((CallExpr { callee, args }, original_len))
|
||||
}
|
||||
|
||||
/// If `s` begins with `ident=`, return (ident, rest_after_eq).
|
||||
fn try_named_arg(s: &str) -> Option<(String, &str)> {
|
||||
let s = s.trim_start();
|
||||
for (i, c) in s.char_indices() {
|
||||
if c == '=' {
|
||||
if i == 0 {
|
||||
return None;
|
||||
}
|
||||
let key = &s[..i];
|
||||
if key.chars().any(|ch| ch.is_whitespace()) {
|
||||
return None;
|
||||
}
|
||||
return Some((key.to_string(), &s[i + 1..]));
|
||||
}
|
||||
if c.is_whitespace() {
|
||||
return None;
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn split_first_token(s: &str) -> (&str, &str) {
|
||||
let s = s.trim_start();
|
||||
if s.starts_with('`') {
|
||||
// `` `name` `` as one token
|
||||
if let Some(end) = s[1..].find('`') {
|
||||
let end = end + 2; // include closing `
|
||||
return (&s[..end], &s[end..]);
|
||||
}
|
||||
}
|
||||
match s.find(char::is_whitespace) {
|
||||
Some(i) => (&s[..i], &s[i..]),
|
||||
None => (s, ""),
|
||||
}
|
||||
}
|
||||
|
||||
fn find_next_arg_boundary(after_eq: &str) -> usize {
|
||||
|
||||
+5
-5
@@ -9,7 +9,7 @@ use anyhow::{bail, Result};
|
||||
use crate::ast::{
|
||||
BranchArm, Expr, Function, Literal, Module, Stmt,
|
||||
};
|
||||
use crate::diagnostics::Span;
|
||||
use crate::diagnostics::{Diagnostic, Span};
|
||||
use crate::lex::{classify_source, ClassifiedLine, LineKind};
|
||||
use crate::parse::expr::parse_call_after_gt as call_after_gt;
|
||||
use crate::parse::expr::parse_expr as parse_expr_str;
|
||||
@@ -217,7 +217,7 @@ impl<'a> Cursor<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
bail!("{span}: unrecognized statement: {trimmed}")
|
||||
Err(Diagnostic::new(None, span, format!("unrecognized statement: {trimmed}")).into())
|
||||
}
|
||||
|
||||
fn parse_backtick_assign(&mut self, trimmed: &str, span: Span) -> Result<Option<Stmt>> {
|
||||
@@ -525,7 +525,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn parse_hello() {
|
||||
let src = include_str!("../../examples/hello.mq.md");
|
||||
let src = include_str!("../../examples/structure/hello.mq.md");
|
||||
let m = parse_source(src).unwrap();
|
||||
assert_eq!(m.functions.len(), 1);
|
||||
assert_eq!(m.functions[0].name, "Hello World");
|
||||
@@ -535,7 +535,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn parse_index() {
|
||||
let src = include_str!("../../examples/index.mq.md");
|
||||
let src = include_str!("../../examples/structure/nested-call.mq.md");
|
||||
let m = parse_source(src).unwrap();
|
||||
assert!(m.imports.is_empty());
|
||||
let main = m.functions.iter().find(|f| f.name == "main").unwrap();
|
||||
@@ -546,7 +546,7 @@ mod tests {
|
||||
|
||||
#[test]
|
||||
fn parse_branch() {
|
||||
let src = include_str!("../../examples/branch.mq.md");
|
||||
let src = include_str!("../../examples/structure/branch.mq.md");
|
||||
let m = parse_source(src).unwrap();
|
||||
let main = &m.functions[0];
|
||||
assert!(main.body.iter().any(|s| matches!(s, Stmt::Branch { .. })));
|
||||
|
||||
@@ -0,0 +1,339 @@
|
||||
//! HTML shell for `marqdo view`.
|
||||
|
||||
use std::path::Path;
|
||||
|
||||
use crate::view::render::FileViewModel;
|
||||
|
||||
pub fn escape(s: &str) -> String {
|
||||
s.chars()
|
||||
.map(|c| match c {
|
||||
'&' => "&".into(),
|
||||
'<' => "<".into(),
|
||||
'>' => ">".into(),
|
||||
'"' => """.into(),
|
||||
'\'' => "'".into(),
|
||||
_ => c.to_string(),
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn layout(title: &str, nav: &str, main: &str) -> String {
|
||||
format!(
|
||||
r##"<!DOCTYPE html>
|
||||
<html lang="zh-CN">
|
||||
<head>
|
||||
<meta charset="utf-8"/>
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1"/>
|
||||
<title>{title} · marqdo view</title>
|
||||
<link rel="preconnect" href="https://fonts.googleapis.com"/>
|
||||
<link href="https://fonts.googleapis.com/css2?family=Fraunces:opsz,wght@9..144,600;9..144,700&family=IBM+Plex+Mono:wght@400;500&family=Sora:wght@400;600&display=swap" rel="stylesheet"/>
|
||||
<style>
|
||||
:root {{
|
||||
--bg0: #0f1c1a;
|
||||
--bg1: #162824;
|
||||
--panel: #1c322d;
|
||||
--ink: #e7f2ee;
|
||||
--muted: #9bb5ac;
|
||||
--accent: #3ecf8e;
|
||||
--accent-dim: #2a9b6a;
|
||||
--call: #5ec8ff;
|
||||
--branch: #f0b429;
|
||||
--loop: #ff7a59;
|
||||
--ret: #c4a7ff;
|
||||
--err: #ff6b6b;
|
||||
--line: rgba(255,255,255,0.08);
|
||||
}}
|
||||
* {{ box-sizing: border-box; }}
|
||||
body {{
|
||||
margin: 0;
|
||||
min-height: 100vh;
|
||||
font-family: "Sora", system-ui, sans-serif;
|
||||
color: var(--ink);
|
||||
background:
|
||||
radial-gradient(1200px 600px at 10% -10%, #1a3d34 0%, transparent 55%),
|
||||
radial-gradient(900px 500px at 100% 0%, #243528 0%, transparent 50%),
|
||||
linear-gradient(165deg, var(--bg0), var(--bg1));
|
||||
}}
|
||||
a {{ color: var(--accent); text-decoration: none; }}
|
||||
a:hover {{ text-decoration: underline; }}
|
||||
.shell {{
|
||||
display: grid;
|
||||
grid-template-columns: minmax(220px, 280px) 1fr;
|
||||
min-height: 100vh;
|
||||
}}
|
||||
@media (max-width: 800px) {{
|
||||
.shell {{ grid-template-columns: 1fr; }}
|
||||
}}
|
||||
.nav {{
|
||||
border-right: 1px solid var(--line);
|
||||
background: rgba(0,0,0,0.22);
|
||||
padding: 1.25rem 1rem 2rem;
|
||||
overflow: auto;
|
||||
}}
|
||||
.brand {{
|
||||
font-family: "Fraunces", Georgia, serif;
|
||||
font-size: 1.45rem;
|
||||
font-weight: 700;
|
||||
letter-spacing: -0.02em;
|
||||
margin: 0 0 0.25rem;
|
||||
}}
|
||||
.brand span {{ color: var(--accent); }}
|
||||
.tagline {{
|
||||
color: var(--muted);
|
||||
font-size: 0.8rem;
|
||||
margin: 0 0 1.25rem;
|
||||
}}
|
||||
.nav h2 {{
|
||||
font-size: 0.7rem;
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 0.12em;
|
||||
color: var(--muted);
|
||||
margin: 1rem 0 0.4rem;
|
||||
}}
|
||||
.nav ul {{ list-style: none; padding: 0; margin: 0; }}
|
||||
.nav li {{ margin: 0.15rem 0; }}
|
||||
.nav a.file {{
|
||||
display: block;
|
||||
padding: 0.35rem 0.5rem;
|
||||
border-radius: 6px;
|
||||
color: var(--ink);
|
||||
font-family: "IBM Plex Mono", monospace;
|
||||
font-size: 0.78rem;
|
||||
}}
|
||||
.nav a.file:hover, .nav a.file.active {{
|
||||
background: rgba(62, 207, 142, 0.12);
|
||||
text-decoration: none;
|
||||
}}
|
||||
.folder {{ color: var(--muted); font-size: 0.75rem; margin-top: 0.75rem; }}
|
||||
main.panel {{
|
||||
padding: 1.5rem 1.75rem 3rem;
|
||||
overflow: auto;
|
||||
}}
|
||||
h1.page {{
|
||||
font-family: "Fraunces", Georgia, serif;
|
||||
font-size: 1.75rem;
|
||||
margin: 0 0 0.5rem;
|
||||
}}
|
||||
.meta {{ color: var(--muted); font-size: 0.85rem; margin-bottom: 1.5rem; }}
|
||||
section.block {{
|
||||
margin: 1.25rem 0 1.75rem;
|
||||
}}
|
||||
section.block > h2 {{
|
||||
font-size: 0.75rem;
|
||||
text-transform: uppercase;
|
||||
letter-spacing: 0.1em;
|
||||
color: var(--muted);
|
||||
margin: 0 0 0.65rem;
|
||||
border-bottom: 1px solid var(--line);
|
||||
padding-bottom: 0.35rem;
|
||||
}}
|
||||
.card {{
|
||||
background: var(--panel);
|
||||
border: 1px solid var(--line);
|
||||
border-radius: 10px;
|
||||
padding: 0.85rem 1rem;
|
||||
margin: 0.55rem 0;
|
||||
}}
|
||||
.fun-card {{ border-left: 3px solid var(--accent); }}
|
||||
.call-card {{ border-left: 3px solid var(--call); }}
|
||||
.branch-card {{ border-left: 3px solid var(--branch); }}
|
||||
.loop-card {{ border-left: 3px solid var(--loop); }}
|
||||
.ret-card {{ border-left: 3px solid var(--ret); }}
|
||||
.badge {{
|
||||
display: inline-block;
|
||||
font-family: "IBM Plex Mono", monospace;
|
||||
font-size: 0.7rem;
|
||||
padding: 0.1rem 0.4rem;
|
||||
border-radius: 4px;
|
||||
background: rgba(255,255,255,0.06);
|
||||
margin-right: 0.35rem;
|
||||
}}
|
||||
.params {{ margin: 0.35rem 0; }}
|
||||
.chip {{
|
||||
display: inline-block;
|
||||
font-family: "IBM Plex Mono", monospace;
|
||||
font-size: 0.75rem;
|
||||
padding: 0.15rem 0.45rem;
|
||||
margin: 0.15rem;
|
||||
border-radius: 999px;
|
||||
background: rgba(62, 207, 142, 0.15);
|
||||
color: var(--accent);
|
||||
}}
|
||||
.nested {{ margin-left: 0.85rem; padding-left: 0.75rem; border-left: 1px dashed var(--line); }}
|
||||
.arm {{
|
||||
margin: 0.4rem 0;
|
||||
padding: 0.5rem 0.65rem;
|
||||
background: rgba(0,0,0,0.2);
|
||||
border-radius: 8px;
|
||||
}}
|
||||
.out {{
|
||||
font-family: "IBM Plex Mono", monospace;
|
||||
font-size: 0.85rem;
|
||||
white-space: pre-wrap;
|
||||
background: #0a1210;
|
||||
border-radius: 8px;
|
||||
padding: 0.85rem 1rem;
|
||||
border: 1px solid var(--line);
|
||||
}}
|
||||
.out.ok {{ box-shadow: inset 3px 0 0 var(--accent-dim); }}
|
||||
.out.fail {{ box-shadow: inset 3px 0 0 var(--err); color: #ffc9c9; }}
|
||||
.source {{
|
||||
font-family: "IBM Plex Mono", monospace;
|
||||
font-size: 0.78rem;
|
||||
white-space: pre-wrap;
|
||||
background: #0a1210;
|
||||
border-radius: 8px;
|
||||
padding: 0.85rem 1rem;
|
||||
border: 1px solid var(--line);
|
||||
line-height: 1.45;
|
||||
}}
|
||||
.err {{ color: var(--err); }}
|
||||
.comment-card {{
|
||||
border-left: 3px solid var(--muted);
|
||||
background: rgba(255,255,255,0.03);
|
||||
}}
|
||||
.comment-text {{
|
||||
color: var(--muted);
|
||||
font-size: 0.9rem;
|
||||
line-height: 1.45;
|
||||
}}
|
||||
code.expr {{
|
||||
font-family: "IBM Plex Mono", monospace;
|
||||
font-size: 0.82rem;
|
||||
color: var(--ink);
|
||||
}}
|
||||
.welcome {{ max-width: 36rem; }}
|
||||
.welcome p {{ color: var(--muted); line-height: 1.55; }}
|
||||
</style>
|
||||
</head>
|
||||
<body>
|
||||
<div class="shell">
|
||||
<aside class="nav">
|
||||
<p class="brand">marq<span>do</span> view</p>
|
||||
<p class="tagline">Markup structure · live output</p>
|
||||
{nav}
|
||||
</aside>
|
||||
<main class="panel">
|
||||
{main}
|
||||
</main>
|
||||
</div>
|
||||
</body>
|
||||
</html>
|
||||
"##,
|
||||
title = escape(title),
|
||||
nav = nav,
|
||||
main = main
|
||||
)
|
||||
}
|
||||
|
||||
pub fn nav_html(files: &[std::path::PathBuf], active: Option<&str>) -> String {
|
||||
let mut out = String::from("<h2>Files</h2><ul>");
|
||||
let mut last_folder = String::new();
|
||||
for f in files {
|
||||
let rel = f.to_string_lossy().replace('\\', "/");
|
||||
let folder = Path::new(&rel)
|
||||
.parent()
|
||||
.map(|p| p.to_string_lossy().to_string())
|
||||
.unwrap_or_default();
|
||||
if folder != last_folder {
|
||||
if !folder.is_empty() {
|
||||
out.push_str(&format!(
|
||||
"</ul><div class=\"folder\">{}</div><ul>",
|
||||
escape(&folder)
|
||||
));
|
||||
}
|
||||
last_folder = folder;
|
||||
}
|
||||
let name = Path::new(&rel)
|
||||
.file_name()
|
||||
.and_then(|s| s.to_str())
|
||||
.unwrap_or(&rel);
|
||||
let active_cls = if active == Some(rel.as_str()) {
|
||||
" active"
|
||||
} else {
|
||||
""
|
||||
};
|
||||
let href = format!("/file?path={}", urlencoding_encode(&rel));
|
||||
out.push_str(&format!(
|
||||
"<li><a class=\"file{active_cls}\" href=\"{href}\">{}</a></li>",
|
||||
escape(name)
|
||||
));
|
||||
}
|
||||
out.push_str("</ul>");
|
||||
out
|
||||
}
|
||||
|
||||
fn urlencoding_encode(s: &str) -> String {
|
||||
let mut out = String::new();
|
||||
for b in s.bytes() {
|
||||
match b {
|
||||
b'A'..=b'Z' | b'a'..=b'z' | b'0'..=b'9' | b'-' | b'_' | b'.' | b'~' | b'/' => {
|
||||
out.push(b as char);
|
||||
}
|
||||
_ => out.push_str(&format!("%{b:02X}")),
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
pub fn page_index(files: &[std::path::PathBuf], only: Option<&Path>) -> String {
|
||||
let nav = nav_html(files, None);
|
||||
let main = if let Some(p) = only {
|
||||
let rel = p.to_string_lossy().replace('\\', "/");
|
||||
format!(
|
||||
"<div class=\"welcome\"><h1 class=\"page\">Single file</h1><p class=\"meta\">Open <a href=\"/file?path={}\">{}</a></p></div>",
|
||||
urlencoding_encode(&rel),
|
||||
escape(&rel)
|
||||
)
|
||||
} else {
|
||||
format!(
|
||||
"<div class=\"welcome\"><h1 class=\"page\">Browse</h1><p>Select a <code>.mq.md</code> file in the index. Structure is rendered from the AST; output comes from the same pipeline as <code>marqdo run</code>.</p><p class=\"meta\">{} file(s)</p></div>",
|
||||
files.len()
|
||||
)
|
||||
};
|
||||
layout("index", &nav, &main)
|
||||
}
|
||||
|
||||
pub fn page_file(files: &[std::path::PathBuf], rel: &str, vm: &FileViewModel) -> String {
|
||||
let nav = nav_html(files, Some(rel));
|
||||
let status = if vm.ok { "ok" } else { "fail" };
|
||||
let out_text = if vm.ok {
|
||||
if vm.stdout.is_empty() {
|
||||
"(no stdout)".to_string()
|
||||
} else {
|
||||
escape(&vm.stdout)
|
||||
}
|
||||
} else {
|
||||
escape(&vm.stderr)
|
||||
};
|
||||
let main = format!(
|
||||
r#"
|
||||
<h1 class="page">{title}</h1>
|
||||
<p class="meta">{rel}</p>
|
||||
<section class="block">
|
||||
<h2>Structure</h2>
|
||||
{structure}
|
||||
</section>
|
||||
<section class="block">
|
||||
<h2>Execution</h2>
|
||||
<div class="out {status}">{out}</div>
|
||||
</section>
|
||||
<section class="block">
|
||||
<h2>Source</h2>
|
||||
<pre class="source">{source}</pre>
|
||||
</section>
|
||||
"#,
|
||||
title = escape(
|
||||
Path::new(rel)
|
||||
.file_stem()
|
||||
.and_then(|s| s.to_str())
|
||||
.unwrap_or(rel)
|
||||
),
|
||||
rel = escape(rel),
|
||||
structure = vm.structure_html,
|
||||
status = status,
|
||||
out = out_text,
|
||||
source = escape(&vm.source),
|
||||
);
|
||||
layout(rel, &nav, &main)
|
||||
}
|
||||
+307
@@ -0,0 +1,307 @@
|
||||
//! `marqdo view` — local HTML browser for `.mq.md` structure + output.
|
||||
|
||||
mod html;
|
||||
mod render;
|
||||
|
||||
use std::fs;
|
||||
use std::net::SocketAddr;
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::Command;
|
||||
|
||||
use anyhow::{bail, Context, Result};
|
||||
use tiny_http::{Header, Method, Request, Response, Server, StatusCode};
|
||||
|
||||
use crate::view::html::{escape, page_file, page_index};
|
||||
use crate::view::render::{render_module_structure, FileViewModel};
|
||||
use crate::{run_file_capture, RunOptions};
|
||||
|
||||
pub struct ViewOptions {
|
||||
pub path: PathBuf,
|
||||
pub host: String,
|
||||
pub port: u16,
|
||||
pub open_browser: bool,
|
||||
}
|
||||
|
||||
struct ViewRoot {
|
||||
/// Directory that paths are resolved against.
|
||||
root: PathBuf,
|
||||
/// If Some, only this relative file is in scope (single-file mode).
|
||||
only_file: Option<PathBuf>,
|
||||
files: Vec<PathBuf>,
|
||||
}
|
||||
|
||||
/// Block serving until Ctrl+C (process kill).
|
||||
pub fn serve(opts: ViewOptions) -> Result<()> {
|
||||
let root_info = build_root(&opts.path)?;
|
||||
let addr: SocketAddr = format!("{}:{}", opts.host, opts.port)
|
||||
.parse()
|
||||
.context("invalid host/port")?;
|
||||
let server = Server::http(addr).map_err(|e| anyhow::anyhow!("listen {addr}: {e}"))?;
|
||||
let url = format!("http://{}:{}/", opts.host, opts.port);
|
||||
eprintln!("marqdo view: {url}");
|
||||
eprintln!("root: {}", root_info.root.display());
|
||||
eprintln!("{} .mq.md file(s). Ctrl+C to stop.", root_info.files.len());
|
||||
|
||||
if opts.open_browser {
|
||||
let _ = open_url(&url);
|
||||
}
|
||||
|
||||
for request in server.incoming_requests() {
|
||||
if let Err(err) = handle(&root_info, request) {
|
||||
eprintln!("view request error: {err:#}");
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn build_root(path: &Path) -> Result<ViewRoot> {
|
||||
let path = if path.exists() {
|
||||
path.canonicalize().unwrap_or_else(|_| path.to_path_buf())
|
||||
} else {
|
||||
bail!("path not found: {}", path.display());
|
||||
};
|
||||
|
||||
if path.is_file() {
|
||||
if !is_mq_md(&path) {
|
||||
bail!("not a .mq.md file: {}", path.display());
|
||||
}
|
||||
let root = path
|
||||
.parent()
|
||||
.map(|p| p.to_path_buf())
|
||||
.unwrap_or_else(|| PathBuf::from("."));
|
||||
let rel = PathBuf::from(path.file_name().unwrap());
|
||||
return Ok(ViewRoot {
|
||||
root,
|
||||
only_file: Some(rel.clone()),
|
||||
files: vec![rel],
|
||||
});
|
||||
}
|
||||
|
||||
if !path.is_dir() {
|
||||
bail!("not a file or directory: {}", path.display());
|
||||
}
|
||||
|
||||
let mut files = Vec::new();
|
||||
collect_mq_md(&path, &path, &mut files)?;
|
||||
files.sort();
|
||||
Ok(ViewRoot {
|
||||
root: path,
|
||||
only_file: None,
|
||||
files,
|
||||
})
|
||||
}
|
||||
|
||||
fn collect_mq_md(root: &Path, dir: &Path, out: &mut Vec<PathBuf>) -> Result<()> {
|
||||
for entry in fs::read_dir(dir).with_context(|| format!("read_dir {}", dir.display()))? {
|
||||
let entry = entry?;
|
||||
let p = entry.path();
|
||||
if p.is_dir() {
|
||||
collect_mq_md(root, &p, out)?;
|
||||
} else if is_mq_md(&p) {
|
||||
let rel = p.strip_prefix(root).unwrap_or(&p).to_path_buf();
|
||||
out.push(rel);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn is_mq_md(path: &Path) -> bool {
|
||||
path.file_name()
|
||||
.and_then(|s| s.to_str())
|
||||
.map(|s| s.ends_with(".mq.md"))
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
fn handle(root: &ViewRoot, request: Request) -> Result<()> {
|
||||
let url = request.url().to_string();
|
||||
let method = request.method().clone();
|
||||
if method != Method::Get {
|
||||
let resp = Response::from_string("method not allowed").with_status_code(StatusCode(405));
|
||||
let _ = request.respond(resp);
|
||||
return Ok(());
|
||||
}
|
||||
|
||||
let (path_part, query) = split_url(&url);
|
||||
match path_part {
|
||||
"/" | "/index.html" => {
|
||||
let body = page_index(&root.files, root.only_file.as_deref());
|
||||
respond_html(request, body)
|
||||
}
|
||||
"/file" => {
|
||||
let rel = query_param(query, "path").unwrap_or_default();
|
||||
let resolved = resolve_rel(root, &rel)?;
|
||||
let vm = build_file_view(&resolved, &rel)?;
|
||||
let body = page_file(&root.files, &rel, &vm);
|
||||
respond_html(request, body)
|
||||
}
|
||||
"/api/tree" => {
|
||||
let json = files_json(&root.files);
|
||||
respond_json(request, json)
|
||||
}
|
||||
_ => {
|
||||
let resp = Response::from_string("not found").with_status_code(StatusCode(404));
|
||||
let _ = request.respond(resp);
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn build_file_view(abs: &Path, rel: &str) -> Result<FileViewModel> {
|
||||
let source = fs::read_to_string(abs).with_context(|| format!("read {}", abs.display()))?;
|
||||
let structure = match crate::load::load_module(abs) {
|
||||
Ok(module) => render_module_structure(&module, &source),
|
||||
Err(e) => format!(
|
||||
"<div class=\"err\">parse/load error: {}</div>",
|
||||
escape(&format!("{e:#}"))
|
||||
),
|
||||
};
|
||||
let (stdout, stderr, ok) = match run_file_capture(abs, &RunOptions::default()) {
|
||||
Ok(cap) => (cap.stdout, String::new(), true),
|
||||
Err(e) => (String::new(), format!("{e:#}"), false),
|
||||
};
|
||||
Ok(FileViewModel {
|
||||
rel_path: rel.to_string(),
|
||||
source,
|
||||
structure_html: structure,
|
||||
stdout,
|
||||
stderr,
|
||||
ok,
|
||||
})
|
||||
}
|
||||
|
||||
fn resolve_rel(root: &ViewRoot, rel: &str) -> Result<PathBuf> {
|
||||
if rel.is_empty() {
|
||||
bail!("missing path");
|
||||
}
|
||||
let rel_path = PathBuf::from(rel.replace('\\', "/"));
|
||||
if rel_path
|
||||
.components()
|
||||
.any(|c| matches!(c, std::path::Component::ParentDir))
|
||||
{
|
||||
bail!("path escapes root");
|
||||
}
|
||||
if let Some(only) = &root.only_file {
|
||||
if &rel_path != only {
|
||||
bail!("file not in view scope");
|
||||
}
|
||||
} else if !root.files.iter().any(|f| f == &rel_path) {
|
||||
// also allow forward-slash normalized compare
|
||||
let norm = rel_path.to_string_lossy().replace('\\', "/");
|
||||
if !root
|
||||
.files
|
||||
.iter()
|
||||
.any(|f| f.to_string_lossy().replace('\\', "/") == norm)
|
||||
{
|
||||
bail!("unknown file: {rel}");
|
||||
}
|
||||
}
|
||||
let abs = root.root.join(&rel_path);
|
||||
let canon = abs.canonicalize().unwrap_or(abs.clone());
|
||||
let root_canon = root.root.canonicalize().unwrap_or_else(|_| root.root.clone());
|
||||
if !canon.starts_with(&root_canon) {
|
||||
bail!("path escapes root");
|
||||
}
|
||||
if !is_mq_md(&canon) {
|
||||
bail!("not a .mq.md file");
|
||||
}
|
||||
Ok(canon)
|
||||
}
|
||||
|
||||
fn split_url(url: &str) -> (&str, &str) {
|
||||
match url.split_once('?') {
|
||||
Some((p, q)) => (p, q),
|
||||
None => (url, ""),
|
||||
}
|
||||
}
|
||||
|
||||
fn query_param<'a>(query: &'a str, key: &str) -> Option<String> {
|
||||
for pair in query.split('&') {
|
||||
let mut kv = pair.splitn(2, '=');
|
||||
let k = kv.next()?;
|
||||
let v = kv.next().unwrap_or("");
|
||||
if k == key {
|
||||
return Some(urlencoding_decode(v));
|
||||
}
|
||||
}
|
||||
None
|
||||
}
|
||||
|
||||
fn urlencoding_decode(s: &str) -> String {
|
||||
// Minimal decode for %XX and +
|
||||
let mut out = String::new();
|
||||
let bytes = s.as_bytes();
|
||||
let mut i = 0;
|
||||
while i < bytes.len() {
|
||||
match bytes[i] {
|
||||
b'+' => {
|
||||
out.push(' ');
|
||||
i += 1;
|
||||
}
|
||||
b'%' if i + 2 < bytes.len() => {
|
||||
let hex = &s[i + 1..i + 3];
|
||||
if let Ok(v) = u8::from_str_radix(hex, 16) {
|
||||
out.push(v as char);
|
||||
i += 3;
|
||||
} else {
|
||||
out.push('%');
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
c => {
|
||||
out.push(c as char);
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
fn files_json(files: &[PathBuf]) -> String {
|
||||
let list: Vec<String> = files
|
||||
.iter()
|
||||
.map(|f| format!("\"{}\"", escape_json(&f.to_string_lossy().replace('\\', "/"))))
|
||||
.collect();
|
||||
format!("{{\"files\":[{}]}}", list.join(","))
|
||||
}
|
||||
|
||||
fn escape_json(s: &str) -> String {
|
||||
s.replace('\\', "\\\\").replace('"', "\\\"")
|
||||
}
|
||||
|
||||
fn respond_html(request: Request, body: String) -> Result<()> {
|
||||
let header = Header::from_bytes(&b"Content-Type"[..], &b"text/html; charset=utf-8"[..])
|
||||
.map_err(|_| anyhow::anyhow!("header"))?;
|
||||
let resp = Response::from_string(body).with_header(header);
|
||||
request.respond(resp).context("respond")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn respond_json(request: Request, body: String) -> Result<()> {
|
||||
let header = Header::from_bytes(&b"Content-Type"[..], &b"application/json; charset=utf-8"[..])
|
||||
.map_err(|_| anyhow::anyhow!("header"))?;
|
||||
let resp = Response::from_string(body).with_header(header);
|
||||
request.respond(resp).context("respond")?;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn open_url(url: &str) -> Result<()> {
|
||||
#[cfg(target_os = "windows")]
|
||||
{
|
||||
Command::new("cmd")
|
||||
.args(["/C", "start", "", url])
|
||||
.spawn()
|
||||
.context("open browser")?;
|
||||
}
|
||||
#[cfg(target_os = "macos")]
|
||||
{
|
||||
Command::new("open").arg(url).spawn().context("open browser")?;
|
||||
}
|
||||
#[cfg(all(unix, not(target_os = "macos")))]
|
||||
{
|
||||
Command::new("xdg-open")
|
||||
.arg(url)
|
||||
.spawn()
|
||||
.context("open browser")?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
@@ -0,0 +1,424 @@
|
||||
//! Render Marqdo AST as HTML fragments for `view`.
|
||||
//!
|
||||
//! Comments are not in the AST; they are interleaved from classified source lines.
|
||||
//! Expressions are shown in surface syntax, never Rust `Debug`.
|
||||
|
||||
use crate::ast::{
|
||||
Arg, BinaryOp, CallExpr, Expr, Function, InterpPart, Literal, Module, Stmt, UnaryOp,
|
||||
};
|
||||
use crate::lex::{classify_source, ClassifiedLine, LineKind};
|
||||
use crate::view::html::escape;
|
||||
|
||||
pub struct FileViewModel {
|
||||
#[allow(dead_code)]
|
||||
pub rel_path: String,
|
||||
pub source: String,
|
||||
pub structure_html: String,
|
||||
pub stdout: String,
|
||||
pub stderr: String,
|
||||
pub ok: bool,
|
||||
}
|
||||
|
||||
pub fn render_module_structure(module: &Module, source: &str) -> String {
|
||||
let lines = classify_source(source);
|
||||
let mut out = String::new();
|
||||
|
||||
if !module.imports.is_empty() {
|
||||
out.push_str("<div class=\"card\"><span class=\"badge\">import</span>");
|
||||
for imp in &module.imports {
|
||||
out.push_str(&format!("<span class=\"chip\">{}</span>", escape(imp)));
|
||||
}
|
||||
out.push_str("</div>");
|
||||
}
|
||||
|
||||
let body_start = skip_frontmatter_end(&lines).unwrap_or(1);
|
||||
let mut cursor = body_start;
|
||||
|
||||
if module.functions.is_empty() {
|
||||
out.push_str(&emit_comments(&lines, cursor, u32::MAX));
|
||||
if out.is_empty() {
|
||||
out.push_str("<p class=\"meta\">(empty module)</p>");
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
// Leading comments before first function
|
||||
let first = module.functions[0].span.line;
|
||||
out.push_str(&emit_comments(&lines, cursor, first));
|
||||
cursor = first;
|
||||
|
||||
for (i, fun) in module.functions.iter().enumerate() {
|
||||
if i > 0 {
|
||||
out.push_str(&emit_comments(&lines, cursor, fun.span.line));
|
||||
}
|
||||
let (html, next) = render_fun(fun, &lines, 0);
|
||||
out.push_str(&html);
|
||||
cursor = next;
|
||||
}
|
||||
|
||||
// Trailing comments after last function tree
|
||||
out.push_str(&emit_comments(&lines, cursor, u32::MAX));
|
||||
out
|
||||
}
|
||||
|
||||
/// Line after closing frontmatter `---`, or 1 if none.
|
||||
fn skip_frontmatter_end(lines: &[ClassifiedLine]) -> Option<u32> {
|
||||
let first_code = lines.iter().find(|l| l.kind == LineKind::Code)?;
|
||||
if first_code.text.trim() != "---" {
|
||||
return Some(1);
|
||||
}
|
||||
for l in lines.iter().skip_while(|l| l.line_no <= first_code.line_no) {
|
||||
if l.kind == LineKind::Code && l.text.trim() == "---" {
|
||||
return Some(l.line_no + 1);
|
||||
}
|
||||
}
|
||||
Some(1)
|
||||
}
|
||||
|
||||
fn emit_comments(lines: &[ClassifiedLine], from_line: u32, before_line: u32) -> String {
|
||||
let mut s = String::new();
|
||||
for l in lines {
|
||||
if l.line_no < from_line {
|
||||
continue;
|
||||
}
|
||||
if l.line_no >= before_line {
|
||||
break;
|
||||
}
|
||||
if l.kind == LineKind::Comment {
|
||||
let text = l.text.trim();
|
||||
if text.is_empty() {
|
||||
continue;
|
||||
}
|
||||
s.push_str(&format!(
|
||||
"<div class=\"card comment-card\"><span class=\"badge\">comment</span><span class=\"comment-text\">{}</span></div>",
|
||||
escape(text)
|
||||
));
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
fn render_fun(fun: &Function, lines: &[ClassifiedLine], depth: usize) -> (String, u32) {
|
||||
let mut s = String::new();
|
||||
let nest = if depth > 0 { " nested" } else { "" };
|
||||
s.push_str(&format!("<div class=\"card fun-card{nest}\">"));
|
||||
s.push_str(&format!(
|
||||
"<div><span class=\"badge\">fn · h{}</span><strong>{}</strong></div>",
|
||||
fun.level,
|
||||
escape(&fun.name)
|
||||
));
|
||||
if !fun.params.is_empty() {
|
||||
s.push_str("<div class=\"params\">");
|
||||
for p in &fun.params {
|
||||
s.push_str(&format!("<span class=\"chip\">{}</span>", escape(p)));
|
||||
}
|
||||
s.push_str("</div>");
|
||||
}
|
||||
|
||||
let mut cursor = fun.span.line + 1;
|
||||
|
||||
// Comments / gap before first body stmt or child
|
||||
let first_body = fun.body.first().map(stmt_start);
|
||||
let first_child = fun.children.first().map(|c| c.span.line);
|
||||
let first_content = match (first_body, first_child) {
|
||||
(Some(a), Some(b)) => Some(a.min(b)),
|
||||
(Some(a), None) => Some(a),
|
||||
(None, Some(b)) => Some(b),
|
||||
(None, None) => None,
|
||||
};
|
||||
if let Some(fc) = first_content {
|
||||
s.push_str(&emit_comments(lines, cursor, fc));
|
||||
cursor = fc;
|
||||
}
|
||||
|
||||
// Interleave body stmts and nested functions by source line
|
||||
let mut bi = 0usize;
|
||||
let mut ci = 0usize;
|
||||
while bi < fun.body.len() || ci < fun.children.len() {
|
||||
let stmt_line = fun.body.get(bi).map(stmt_start);
|
||||
let child_line = fun.children.get(ci).map(|c| c.span.line);
|
||||
let take_stmt = match (stmt_line, child_line) {
|
||||
(Some(sl), Some(cl)) => sl <= cl,
|
||||
(Some(_), None) => true,
|
||||
(None, Some(_)) => false,
|
||||
(None, None) => break,
|
||||
};
|
||||
if take_stmt {
|
||||
let stmt = &fun.body[bi];
|
||||
let start = stmt_start(stmt);
|
||||
s.push_str(&emit_comments(lines, cursor, start));
|
||||
let (html, end) = render_stmt(stmt, lines);
|
||||
s.push_str(&html);
|
||||
cursor = end;
|
||||
bi += 1;
|
||||
} else {
|
||||
let child = &fun.children[ci];
|
||||
s.push_str(&emit_comments(lines, cursor, child.span.line));
|
||||
let (html, end) = render_fun(child, lines, depth + 1);
|
||||
s.push_str(&format!("<div class=\"nested\">{html}</div>"));
|
||||
cursor = end;
|
||||
ci += 1;
|
||||
}
|
||||
}
|
||||
|
||||
s.push_str("</div>");
|
||||
(s, cursor)
|
||||
}
|
||||
|
||||
fn stmt_start(stmt: &Stmt) -> u32 {
|
||||
match stmt {
|
||||
Stmt::Assign { span, .. }
|
||||
| Stmt::Return { span, .. }
|
||||
| Stmt::Call { span, .. }
|
||||
| Stmt::Branch { span, .. }
|
||||
| Stmt::While { span, .. }
|
||||
| Stmt::ForEach { span, .. } => span.line,
|
||||
}
|
||||
}
|
||||
|
||||
fn stmt_end_line(stmt: &Stmt) -> u32 {
|
||||
match stmt {
|
||||
Stmt::Assign { span, .. } | Stmt::Return { span, .. } | Stmt::Call { span, .. } => {
|
||||
span.line + 1
|
||||
}
|
||||
Stmt::Branch { arms, span, .. } => {
|
||||
let mut end = span.line + 1;
|
||||
for arm in arms {
|
||||
for st in &arm.body {
|
||||
end = end.max(stmt_end_line(st));
|
||||
}
|
||||
}
|
||||
end
|
||||
}
|
||||
Stmt::While { body, span, .. } | Stmt::ForEach { body, span, .. } => {
|
||||
let mut end = span.line + 1;
|
||||
for st in body {
|
||||
end = end.max(stmt_end_line(st));
|
||||
}
|
||||
end
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn render_stmt(stmt: &Stmt, lines: &[ClassifiedLine]) -> (String, u32) {
|
||||
let end = stmt_end_line(stmt);
|
||||
let html = match stmt {
|
||||
Stmt::Assign { name, value, .. } => format!(
|
||||
"<div class=\"card\"><span class=\"badge\">bind</span><code class=\"expr\">`{}` = {}</code></div>",
|
||||
escape(name),
|
||||
escape(&expr_display(value))
|
||||
),
|
||||
Stmt::Return { value, .. } => format!(
|
||||
"<div class=\"card ret-card\"><span class=\"badge\">return</span><code class=\"expr\">{}</code></div>",
|
||||
escape(&expr_display(value))
|
||||
),
|
||||
Stmt::Call { call, .. } => format!(
|
||||
"<div class=\"card call-card\"><span class=\"badge\">call</span><code class=\"expr\">{}</code></div>",
|
||||
escape(&call_display(call))
|
||||
),
|
||||
Stmt::Branch { arms, .. } => {
|
||||
let mut inner =
|
||||
String::from("<div class=\"card branch-card\"><span class=\"badge\">branch</span>");
|
||||
let mut arm_cursor = stmt_start(stmt) + 1;
|
||||
for arm in arms {
|
||||
let label = match &arm.condition {
|
||||
None => "else".to_string(),
|
||||
Some(c) => expr_display(c),
|
||||
};
|
||||
// comments before first stmt in arm (approx: between arms hard; use body starts)
|
||||
let arm_first = arm.body.first().map(stmt_start);
|
||||
inner.push_str(&format!(
|
||||
"<div class=\"arm\"><span class=\"badge\">arm</span><code class=\"expr\">{}</code>",
|
||||
escape(&label)
|
||||
));
|
||||
if let Some(af) = arm_first {
|
||||
inner.push_str(&emit_comments(lines, arm_cursor, af));
|
||||
arm_cursor = af;
|
||||
}
|
||||
inner.push_str("<div class=\"nested\">");
|
||||
for st in &arm.body {
|
||||
let start = stmt_start(st);
|
||||
inner.push_str(&emit_comments(lines, arm_cursor, start));
|
||||
let (h, e) = render_stmt(st, lines);
|
||||
inner.push_str(&h);
|
||||
arm_cursor = e;
|
||||
}
|
||||
inner.push_str("</div></div>");
|
||||
}
|
||||
inner.push_str("</div>");
|
||||
inner
|
||||
}
|
||||
Stmt::While {
|
||||
condition, body, ..
|
||||
} => {
|
||||
let mut inner = format!(
|
||||
"<div class=\"card loop-card\"><span class=\"badge\">while</span><code class=\"expr\">{}</code><div class=\"nested\">",
|
||||
escape(&expr_display(condition))
|
||||
);
|
||||
let mut cursor = stmt_start(stmt) + 1;
|
||||
for st in body {
|
||||
let start = stmt_start(st);
|
||||
inner.push_str(&emit_comments(lines, cursor, start));
|
||||
let (h, e) = render_stmt(st, lines);
|
||||
inner.push_str(&h);
|
||||
cursor = e;
|
||||
}
|
||||
inner.push_str("</div></div>");
|
||||
inner
|
||||
}
|
||||
Stmt::ForEach {
|
||||
item,
|
||||
collection,
|
||||
body,
|
||||
..
|
||||
} => {
|
||||
let mut inner = format!(
|
||||
"<div class=\"card loop-card\"><span class=\"badge\">foreach</span><code class=\"expr\">[{}]({})</code><div class=\"nested\">",
|
||||
escape(item),
|
||||
escape(collection)
|
||||
);
|
||||
let mut cursor = stmt_start(stmt) + 1;
|
||||
for st in body {
|
||||
let start = stmt_start(st);
|
||||
inner.push_str(&emit_comments(lines, cursor, start));
|
||||
let (h, e) = render_stmt(st, lines);
|
||||
inner.push_str(&h);
|
||||
cursor = e;
|
||||
}
|
||||
inner.push_str("</div></div>");
|
||||
inner
|
||||
}
|
||||
};
|
||||
(html, end)
|
||||
}
|
||||
|
||||
fn call_display(call: &CallExpr) -> String {
|
||||
let mut s = format!("> {}", call.callee);
|
||||
for a in &call.args {
|
||||
match a {
|
||||
Arg::Positional(e) => {
|
||||
s.push(' ');
|
||||
s.push_str(&expr_display(e));
|
||||
}
|
||||
Arg::Named { name, value } => {
|
||||
s.push(' ');
|
||||
s.push_str(name);
|
||||
s.push('=');
|
||||
s.push_str(&expr_display(value));
|
||||
}
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
|
||||
/// Surface-syntax preview for view (not Debug).
|
||||
pub fn expr_display(expr: &Expr) -> String {
|
||||
expr_prec(expr, 0)
|
||||
}
|
||||
|
||||
fn expr_prec(expr: &Expr, parent_prec: u8) -> String {
|
||||
match expr {
|
||||
Expr::Literal(lit) => lit_display(lit),
|
||||
Expr::Var(name) => format!("`{name}`"),
|
||||
Expr::Interp(parts) => {
|
||||
let mut s = String::new();
|
||||
for p in parts {
|
||||
match p {
|
||||
InterpPart::Lit(t) => s.push_str(t),
|
||||
InterpPart::Var(n) => {
|
||||
s.push('`');
|
||||
s.push_str(n);
|
||||
s.push('`');
|
||||
}
|
||||
}
|
||||
}
|
||||
s
|
||||
}
|
||||
Expr::Unary { op, expr } => {
|
||||
let prec = 5;
|
||||
let inner = match op {
|
||||
UnaryOp::Not => format!("not {}", expr_prec(expr, prec)),
|
||||
UnaryOp::Neg => format!("-{}", expr_prec(expr, prec)),
|
||||
};
|
||||
wrap(inner, prec, parent_prec)
|
||||
}
|
||||
Expr::Binary { op, left, right } => {
|
||||
let (sym, prec) = bin_sym_prec(*op);
|
||||
let inner = format!(
|
||||
"{} {} {}",
|
||||
expr_prec(left, prec),
|
||||
sym,
|
||||
expr_prec(right, prec + 1) // left-assoc bias
|
||||
);
|
||||
wrap(inner, prec, parent_prec)
|
||||
}
|
||||
Expr::Call(call) => call_display(call),
|
||||
Expr::List(items) => {
|
||||
let parts: Vec<String> = items.iter().map(|e| expr_prec(e, 0)).collect();
|
||||
format!("[{}]", parts.join(", "))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn wrap(inner: String, prec: u8, parent_prec: u8) -> String {
|
||||
if prec < parent_prec {
|
||||
format!("({inner})")
|
||||
} else {
|
||||
inner
|
||||
}
|
||||
}
|
||||
|
||||
fn bin_sym_prec(op: BinaryOp) -> (&'static str, u8) {
|
||||
match op {
|
||||
BinaryOp::Or => ("or", 1),
|
||||
BinaryOp::And => ("and", 2),
|
||||
BinaryOp::Eq => ("==", 3),
|
||||
BinaryOp::Ne => ("!=", 3),
|
||||
BinaryOp::Lt => ("<", 3),
|
||||
BinaryOp::Le => ("<=", 3),
|
||||
BinaryOp::Gt => (">", 3),
|
||||
BinaryOp::Ge => (">=", 3),
|
||||
BinaryOp::Add => ("+", 4),
|
||||
BinaryOp::Sub => ("-", 4),
|
||||
BinaryOp::Mul => ("*", 5),
|
||||
BinaryOp::Div => ("/", 5),
|
||||
}
|
||||
}
|
||||
|
||||
fn lit_display(lit: &Literal) -> String {
|
||||
match lit {
|
||||
Literal::None => "None".into(),
|
||||
Literal::Bool(true) => "True".into(),
|
||||
Literal::Bool(false) => "False".into(),
|
||||
Literal::Int(n) => n.to_string(),
|
||||
Literal::Text(t) => t.clone(),
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
use crate::ast::{BinaryOp, Expr, Literal};
|
||||
|
||||
#[test]
|
||||
fn expr_gt_is_surface() {
|
||||
let e = Expr::Binary {
|
||||
op: BinaryOp::Gt,
|
||||
left: Box::new(Expr::Var("x".into())),
|
||||
right: Box::new(Expr::Literal(Literal::Int(0))),
|
||||
};
|
||||
assert_eq!(expr_display(&e), "`x` > 0");
|
||||
assert!(!expr_display(&e).contains("Binary"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn structure_keeps_comments_and_surface_expr() {
|
||||
let src = include_str!("../../examples/structure/nested-call.mq.md");
|
||||
let module = crate::parse::parse_source(src).unwrap();
|
||||
let html = render_module_structure(&module, src);
|
||||
assert!(html.contains("comment-card"));
|
||||
assert!(html.contains("print"));
|
||||
assert!(!html.contains("Binary {"));
|
||||
assert!(!html.contains("Literal(Int"));
|
||||
}
|
||||
}
|
||||
@@ -1,65 +0,0 @@
|
||||
use std::process::Command;
|
||||
|
||||
fn run(args: &[&str]) -> (i32, String, String) {
|
||||
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
|
||||
.args(args)
|
||||
.output()
|
||||
.expect("failed to run marqdo");
|
||||
let code = output.status.code().unwrap_or(1);
|
||||
let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
|
||||
let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
|
||||
(code, stdout, stderr)
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hello_prints_greeting() {
|
||||
let (code, stdout, stderr) = run(&["run", "examples/hello.mq.md"]);
|
||||
assert_eq!(code, 0, "stderr={stderr}");
|
||||
assert_eq!(stdout.trim_end(), "Hello World!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn index_nested_call() {
|
||||
let (code, stdout, stderr) = run(&["run", "examples/index.mq.md"]);
|
||||
assert_eq!(code, 0, "stderr={stderr}");
|
||||
assert_eq!(stdout.trim_end(), "Hello World!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn branch_else_arm() {
|
||||
let (code, stdout, stderr) = run(&["run", "examples/branch.mq.md"]);
|
||||
assert_eq!(code, 0, "stderr={stderr}");
|
||||
assert_eq!(stdout.trim_end(), "零");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn loop_while_and_foreach() {
|
||||
let (code, stdout, stderr) = run(&["run", "examples/loop.mq.md"]);
|
||||
assert_eq!(code, 0, "stderr={stderr}");
|
||||
assert_eq!(
|
||||
stdout.trim_end(),
|
||||
"3\n2\n1\n今天吃苹果\n今天吃梨"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn collection_foreach() {
|
||||
let (code, stdout, stderr) = run(&["run", "examples/collection.mq.md"]);
|
||||
assert_eq!(code, 0, "stderr={stderr}");
|
||||
assert_eq!(stdout.trim_end(), "苹果\n梨\n桃");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn with_import() {
|
||||
let (code, stdout, stderr) = run(&["run", "examples/with-import.mq.md"]);
|
||||
assert_eq!(code, 0, "stderr={stderr}");
|
||||
assert_eq!(stdout.trim_end(), "42\n你好,Marqdo!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn hello_dump_lines_still_runs() {
|
||||
let (code, stdout, stderr) = run(&["run", "examples/hello.mq.md", "--dump-lines"]);
|
||||
assert_eq!(code, 0, "stderr={stderr}");
|
||||
assert!(stdout.contains("=== marqdo: lines"));
|
||||
assert!(stdout.contains("Hello World!"));
|
||||
}
|
||||
+206
@@ -0,0 +1,206 @@
|
||||
use std::process::Command;
|
||||
|
||||
fn run(args: &[&str]) -> (i32, String, String) {
|
||||
let output = Command::new(env!("CARGO_BIN_EXE_marqdo"))
|
||||
.args(args)
|
||||
.output()
|
||||
.expect("failed to run marqdo");
|
||||
let code = output.status.code().unwrap_or(1);
|
||||
let stdout = String::from_utf8_lossy(&output.stdout).into_owned();
|
||||
let stderr = String::from_utf8_lossy(&output.stderr).into_owned();
|
||||
(code, stdout, stderr)
|
||||
}
|
||||
|
||||
fn assert_out(path: &str, expect: &str) {
|
||||
let (code, stdout, stderr) = run(&["run", path]);
|
||||
assert_eq!(code, 0, "{path} stderr={stderr}");
|
||||
assert_eq!(stdout.trim_end(), expect.trim_end(), "{path}");
|
||||
}
|
||||
|
||||
fn assert_err(path: &str, substr: &str) {
|
||||
let (code, stdout, stderr) = run(&["run", path]);
|
||||
assert_ne!(code, 0, "{path} unexpectedly succeeded stdout={stdout}");
|
||||
assert!(
|
||||
stderr.contains(substr),
|
||||
"{path} stderr missing {substr:?}: {stderr}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn structure_hello() {
|
||||
assert_out("examples/structure/hello.mq.md", "Hello World!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn structure_nested_call() {
|
||||
assert_out("examples/structure/nested-call.mq.md", "Hello World!");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn structure_positional_call() {
|
||||
assert_out(
|
||||
"examples/structure/positional-call.mq.md",
|
||||
"Hello Marqdo!\nHello World!",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn structure_branch() {
|
||||
assert_out("examples/structure/branch.mq.md", "零");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn structure_loop() {
|
||||
assert_out(
|
||||
"examples/structure/loop.mq.md",
|
||||
"3\n2\n1\n今天吃苹果\n今天吃梨",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn structure_collection() {
|
||||
assert_out("examples/structure/collection.mq.md", "苹果\n梨\n桃");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn structure_import() {
|
||||
assert_out(
|
||||
"examples/structure/import/main.mq.md",
|
||||
"42\n你好,Marqdo!",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keywords_print() {
|
||||
assert_out(
|
||||
"examples/keywords/print.mq.md",
|
||||
"named form\npositional",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn keywords_bool_logic() {
|
||||
assert_out(
|
||||
"examples/keywords/bool-logic.mq.md",
|
||||
"ok\nnone-falsy",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn error_undefined_var() {
|
||||
assert_err(
|
||||
"examples/errors/undefined-var.mq.md",
|
||||
"undefined variable `missing`",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn error_unknown_fn() {
|
||||
assert_err(
|
||||
"examples/errors/unknown-fn.mq.md",
|
||||
"unknown function `no_such_fn`",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn error_bad_arity() {
|
||||
assert_err(
|
||||
"examples/errors/bad-arity.mq.md",
|
||||
"missing argument for parameter `x`",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn error_syntax_bad_line() {
|
||||
assert_err(
|
||||
"examples/errors/syntax-bad-line.mq.md",
|
||||
"unrecognized statement",
|
||||
);
|
||||
}
|
||||
|
||||
fn assert_out_backend(path: &str, backend: &str, expect: &str) {
|
||||
let (code, stdout, stderr) = run(&["run", path, "--backend", backend]);
|
||||
assert_eq!(code, 0, "{path} backend={backend} stderr={stderr}");
|
||||
assert_eq!(
|
||||
stdout.trim_end(),
|
||||
expect.trim_end(),
|
||||
"{path} backend={backend}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytecode_hello() {
|
||||
assert_out_backend(
|
||||
"examples/structure/hello.mq.md",
|
||||
"bytecode",
|
||||
"Hello World!",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytecode_branch() {
|
||||
assert_out_backend("examples/structure/branch.mq.md", "bytecode", "零");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytecode_loop() {
|
||||
assert_out_backend(
|
||||
"examples/structure/loop.mq.md",
|
||||
"bytecode",
|
||||
"3\n2\n1\n今天吃苹果\n今天吃梨",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytecode_collection() {
|
||||
assert_out_backend(
|
||||
"examples/structure/collection.mq.md",
|
||||
"bytecode",
|
||||
"苹果\n梨\n桃",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytecode_print_keyword() {
|
||||
assert_out_backend(
|
||||
"examples/keywords/print.mq.md",
|
||||
"bytecode",
|
||||
"named form\npositional",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytecode_bool_logic() {
|
||||
assert_out_backend(
|
||||
"examples/keywords/bool-logic.mq.md",
|
||||
"bytecode",
|
||||
"ok\nnone-falsy",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytecode_nested_call() {
|
||||
assert_out_backend(
|
||||
"examples/structure/nested-call.mq.md",
|
||||
"bytecode",
|
||||
"Hello World!",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytecode_positional_call() {
|
||||
assert_out_backend(
|
||||
"examples/structure/positional-call.mq.md",
|
||||
"bytecode",
|
||||
"Hello Marqdo!\nHello World!",
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bytecode_import() {
|
||||
assert_out_backend(
|
||||
"examples/structure/import/main.mq.md",
|
||||
"bytecode",
|
||||
"42\n你好,Marqdo!",
|
||||
);
|
||||
}
|
||||
Reference in new issue
Block a user