feat(rfc-cm): baseline P0-P3 compute machine, stdlib and resource slices
Implements the first vertical slices of RFC-CM-0001/0002 on top of a113d89:
- P1: opaque Memory regions (64 KiB pages, budgets, grow-only), byte
read/write, Memory-index place assignment, wire/host-boundary rejection.
- CM-A04/A05: value-semantics List/Map/Text/Table primitives and the
recoverable Result map convention.
- CM-A06: opaque Resource handles, resource.open/read/write/close, stdout
write, granted project-file read and buffered write, strict fail-closed.
- CM-A07 Compat-A: explicit .mq.md format/utf8/io chain matching builtin
print for the covered value types; builtin remains default.
- P2 fixtures: allocators, list/tree/graph/hash, integer codecs, UTF-8
encode/decode, CSV/JSON subsets, table filter/sort/join, bytecode VM.
- ADRs 0022-0027, spec updates, evidence reports and 68 semantic goldens.
Gate: cargo fmt --check, clippy -D warnings, 407 tests passed.
This commit is contained in:
1 parent
a113d89496
commit
92bfbf2568
127 files changed
+11351
-141
No files matched your search
@@ -8,7 +8,9 @@
|
||||
use std::path::Path;
|
||||
|
||||
use marqdo_expression::{BinaryOp, Expr, UnaryOp};
|
||||
use marqdo_ir::{CallTarget, Function, Module, ModuleId, Resource, SignatureKind, Stmt, UnitKind};
|
||||
use marqdo_ir::{
|
||||
CallTarget, Function, Module, ModuleId, PlaceTarget, Resource, SignatureKind, Stmt, UnitKind,
|
||||
};
|
||||
use marqdo_span::Span;
|
||||
use serde_json::{json, Value};
|
||||
use sha2::{Digest, Sha256};
|
||||
@@ -232,13 +234,31 @@ fn function_json(function: &Function) -> Value {
|
||||
})
|
||||
}
|
||||
|
||||
/// Project an assignment place. Local targets keep the v1 string form; the new
|
||||
/// index target is an additive object so existing consumers that compare the
|
||||
/// local `target` string are unaffected (Analysis v2, ADR-0022).
|
||||
fn place_json(place: &PlaceTarget) -> Value {
|
||||
match place {
|
||||
PlaceTarget::Local { name, .. } => Value::String(name.clone()),
|
||||
PlaceTarget::Index { base, index, span } => json!({
|
||||
"kind": "index",
|
||||
"base": expr_json(base),
|
||||
"index": expr_json(index),
|
||||
"span": span_json(*span),
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
fn stmt_json(stmt: &Stmt) -> Value {
|
||||
match stmt {
|
||||
Stmt::Assign {
|
||||
name, value, span, ..
|
||||
target,
|
||||
value,
|
||||
span,
|
||||
..
|
||||
} => json!({
|
||||
"kind": "assign",
|
||||
"target": name,
|
||||
"target": place_json(target),
|
||||
"value": expr_json(value),
|
||||
"span": span_json(*span),
|
||||
}),
|
||||
@@ -497,9 +517,14 @@ fn collect_calls(
|
||||
) {
|
||||
for stmt in body {
|
||||
match stmt {
|
||||
Stmt::Assign { value, .. } | Stmt::Eval { expr: value, .. } => {
|
||||
expr_calls(project, module, function, value, calls)
|
||||
Stmt::Assign { target, value, .. } => {
|
||||
if let PlaceTarget::Index { base, index, .. } = target {
|
||||
expr_calls(project, module, function, base, calls);
|
||||
expr_calls(project, module, function, index, calls);
|
||||
}
|
||||
expr_calls(project, module, function, value, calls);
|
||||
}
|
||||
Stmt::Eval { expr: value, .. } => expr_calls(project, module, function, value, calls),
|
||||
Stmt::Return { value, .. } => expr_calls(project, module, function, value, calls),
|
||||
Stmt::Call { call, span } => calls.push(json!({
|
||||
"function": function.id.to_string(),
|
||||
|
||||
@@ -4,7 +4,7 @@ use std::path::{Path, PathBuf};
|
||||
use std::time::{Duration, Instant};
|
||||
|
||||
use marqdo_host::{Capabilities, Host, StdHost};
|
||||
use marqdo_runtime::{run, EvaluatedArg, RuntimeError, Value};
|
||||
use marqdo_runtime::{run_with_limits, EvaluatedArg, MemoryLimits, RuntimeError, Value};
|
||||
use marqdo_sandbox::{PlatformCapabilities, SandboxMode};
|
||||
use marqdo_span::Span;
|
||||
use serde_json::json;
|
||||
@@ -32,6 +32,10 @@ pub struct SandboxSettings {
|
||||
pub stack: Option<usize>,
|
||||
/// Output limit override.
|
||||
pub max_output: Option<usize>,
|
||||
/// Total committed addressable-memory budget override (bytes).
|
||||
pub max_memory: Option<usize>,
|
||||
/// Per-region committed addressable-memory budget override (bytes).
|
||||
pub max_region_memory: Option<usize>,
|
||||
/// Wall-clock timeout in seconds.
|
||||
pub timeout: Option<u64>,
|
||||
/// Explicitly trusted plugin manifests to load.
|
||||
@@ -884,12 +888,21 @@ pub fn execute(
|
||||
.iter()
|
||||
.map(|(name, value)| EvaluatedArg::named(name.clone(), value.clone(), Span::default()))
|
||||
.collect();
|
||||
let result = run(
|
||||
let memory_limits = MemoryLimits {
|
||||
max_total_bytes: settings
|
||||
.max_memory
|
||||
.unwrap_or(marqdo_runtime::DEFAULT_MAX_TOTAL_BYTES),
|
||||
max_region_bytes: settings
|
||||
.max_region_memory
|
||||
.unwrap_or(marqdo_runtime::DEFAULT_MAX_REGION_BYTES),
|
||||
};
|
||||
let result = run_with_limits(
|
||||
&project.program,
|
||||
&mut host,
|
||||
&project.entry,
|
||||
&function_name,
|
||||
runtime_args,
|
||||
memory_limits,
|
||||
);
|
||||
if let Some(path) = &settings.trace_file {
|
||||
let status = match &result {
|
||||
|
||||
@@ -103,6 +103,12 @@ struct SandboxArgs {
|
||||
/// Override the program output byte limit.
|
||||
#[arg(long = "max-output")]
|
||||
max_output: Option<usize>,
|
||||
/// Override the total committed addressable-memory budget in bytes.
|
||||
#[arg(long = "max-memory", value_name = "BYTES")]
|
||||
max_memory: Option<usize>,
|
||||
/// Override the per-region committed addressable-memory budget in bytes.
|
||||
#[arg(long = "max-region-memory", value_name = "BYTES")]
|
||||
max_region_memory: Option<usize>,
|
||||
/// Wall-clock timeout in seconds.
|
||||
#[arg(long)]
|
||||
timeout: Option<u64>,
|
||||
@@ -137,6 +143,8 @@ impl SandboxArgs {
|
||||
fuel: self.fuel,
|
||||
stack: self.stack,
|
||||
max_output: self.max_output,
|
||||
max_memory: self.max_memory,
|
||||
max_region_memory: self.max_region_memory,
|
||||
timeout: self.timeout,
|
||||
plugins: self.plugin.clone(),
|
||||
trust_native_plugin: self.trust_native_plugin,
|
||||
|
||||
@@ -181,6 +181,34 @@ fn analysis_v2_identity_is_location_independent() {
|
||||
assert_eq!(analysis["project"]["identity_kind"], "manifest");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn analysis_v2_projects_memory_place_targets_additively() {
|
||||
let dir = TempDir::new("analysis-place");
|
||||
let source = "## main\n\n**内存 = memory.new(1, 2)**\n\n**`内存[0] = 7`**\n\n*内存[0]*\n";
|
||||
write(dir.path(), "index.mq.md", source);
|
||||
let target = dir.path().join("analysis.json");
|
||||
let output = cli(
|
||||
dir.path(),
|
||||
&["check", "index.mq.md", "--emit", target.to_str().unwrap()],
|
||||
);
|
||||
assert_eq!(
|
||||
output.status.code(),
|
||||
Some(0),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
let analysis: serde_json::Value =
|
||||
serde_json::from_slice(&std::fs::read(&target).unwrap()).unwrap();
|
||||
let body = analysis["modules"][0]["functions"][0]["body"]
|
||||
.as_array()
|
||||
.expect("body is an array");
|
||||
assert_eq!(body[0]["target"], "内存");
|
||||
assert_eq!(body[1]["target"]["kind"], "index");
|
||||
assert_eq!(body[1]["target"]["base"]["kind"], "variable");
|
||||
assert_eq!(body[1]["target"]["index"]["kind"], "literal");
|
||||
assert_eq!(body[1]["target"]["index"]["type"], "int");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn analysis_v2_projects_addressable_formula_and_code_resources() {
|
||||
let dir = TempDir::new("analysis-resources");
|
||||
|
||||
@@ -24,6 +24,49 @@ fn stderr(output: &Output) -> String {
|
||||
String::from_utf8_lossy(&output.stderr).to_string()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn mqmd_stdlib_print_output_matches_builtin_print() {
|
||||
let output = cli(&["run", "examples/stdlib/demo.mq.md"]);
|
||||
assert_eq!(output.status.code(), Some(0), "{}", stderr(&output));
|
||||
let stdout = String::from_utf8_lossy(&output.stdout);
|
||||
let lines: Vec<&str> = stdout.lines().collect();
|
||||
assert_eq!(lines.len(), 4, "{stdout:?}");
|
||||
assert_eq!(lines[0], lines[1], "list formatting differs from 打印");
|
||||
assert_eq!(lines[2], lines[3], "table formatting differs from 打印");
|
||||
assert_eq!(
|
||||
lines[0],
|
||||
r#"["文本", 2, 1.5, [3, true], {a: 1, b: "x"}, None]"#
|
||||
);
|
||||
assert_eq!(lines[2], "Table[名称 | 分数]{甲 | 87; 乙 | 92}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn addressable_memory_example_runs_through_the_cli() {
|
||||
let output = cli(&["run", "examples/memory-buffer.mq.md", "--json"]);
|
||||
assert_eq!(output.status.code(), Some(0), "{}", stderr(&output));
|
||||
let report: serde_json::Value =
|
||||
serde_json::from_slice(&output.stdout).expect("run --json emits JSON");
|
||||
assert_eq!(report["success"], true);
|
||||
assert_eq!(report["value"]["type"], "int");
|
||||
assert_eq!(report["value"]["decimal"], "141");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cli_memory_budget_override_fails_closed() {
|
||||
let output = cli(&[
|
||||
"run",
|
||||
"examples/memory-buffer.mq.md",
|
||||
"--max-memory",
|
||||
"0",
|
||||
"--json",
|
||||
]);
|
||||
assert_eq!(output.status.code(), Some(1), "{}", stderr(&output));
|
||||
let report: serde_json::Value =
|
||||
serde_json::from_slice(&output.stdout).expect("run --json emits JSON");
|
||||
assert_eq!(report["success"], false);
|
||||
assert_eq!(report["error"]["code"], "resource.exhausted");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn multi_version_packages_run_without_an_implicit_override() {
|
||||
let output = cli(&["run", "examples/packages-multi-version/index.mq.md"]);
|
||||
|
||||
@@ -0,0 +1,235 @@
|
||||
//! End-to-end resource stream tests through the CLI.
|
||||
|
||||
use std::path::{Path, PathBuf};
|
||||
use std::process::{Command, Output};
|
||||
|
||||
struct TempDir(PathBuf);
|
||||
|
||||
impl TempDir {
|
||||
fn new(tag: &str) -> Self {
|
||||
let path =
|
||||
std::env::temp_dir().join(format!("marqdo-resource-test-{}-{tag}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&path);
|
||||
std::fs::create_dir_all(&path).unwrap();
|
||||
Self(path)
|
||||
}
|
||||
|
||||
fn path(&self) -> &Path {
|
||||
&self.0
|
||||
}
|
||||
}
|
||||
|
||||
impl Drop for TempDir {
|
||||
fn drop(&mut self) {
|
||||
let _ = std::fs::remove_dir_all(&self.0);
|
||||
}
|
||||
}
|
||||
|
||||
fn cli(dir: &Path, args: &[&str]) -> Output {
|
||||
Command::new(env!("CARGO_BIN_EXE_marqdo"))
|
||||
.args(args)
|
||||
.current_dir(dir)
|
||||
.output()
|
||||
.expect("run marqdo")
|
||||
}
|
||||
|
||||
fn write_file(path: &Path, contents: &str) {
|
||||
std::fs::write(path, contents).unwrap();
|
||||
}
|
||||
|
||||
const READER: &str = r#"## main
|
||||
|
||||
**内存 = memory.new(1, 1)**
|
||||
|
||||
**流 = resource.open("file", "data.txt", ["read"])**
|
||||
|
||||
**第一次 = resource.read(流, 内存, 0, 2)**
|
||||
|
||||
**第二次 = resource.read(流, 内存, 2, 4)**
|
||||
|
||||
**第三次 = resource.read(流, 内存, 6, 1)**
|
||||
|
||||
**关闭 = resource.close(流)**
|
||||
|
||||
*[第一次.value.count, 第一次.value.eof, 第二次.value.count, 第二次.value.eof, 第三次.value.count, 第三次.value.eof, 内存[0], 内存[1], 内存[2], 内存[3], 内存[4], 内存[5], 关闭.ok]*
|
||||
"#;
|
||||
|
||||
#[test]
|
||||
fn project_file_stream_reads_chunks_into_memory() {
|
||||
let dir = TempDir::new("file-read");
|
||||
write_file(&dir.path().join("data.txt"), "abcdef");
|
||||
write_file(&dir.path().join("index.mq.md"), READER);
|
||||
let output = cli(
|
||||
dir.path(),
|
||||
&["run", "index.mq.md", "--allow-read", "data.txt", "--json"],
|
||||
);
|
||||
assert_eq!(
|
||||
output.status.code(),
|
||||
Some(0),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
let report: serde_json::Value = serde_json::from_slice(&output.stdout).expect("json output");
|
||||
assert_eq!(report["success"], true);
|
||||
let values: Vec<&serde_json::Value> = report["value"]["items"]
|
||||
.as_array()
|
||||
.expect("list result")
|
||||
.iter()
|
||||
.collect();
|
||||
assert_eq!(values[0]["decimal"], "2");
|
||||
assert_eq!(values[1]["value"], false);
|
||||
assert_eq!(values[2]["decimal"], "4");
|
||||
assert_eq!(values[3]["value"], true);
|
||||
assert_eq!(values[4]["decimal"], "0");
|
||||
assert_eq!(values[5]["value"], true);
|
||||
for (index, expected) in ["97", "98", "99", "100", "101", "102"]
|
||||
.into_iter()
|
||||
.enumerate()
|
||||
{
|
||||
assert_eq!(values[6 + index]["decimal"], expected);
|
||||
}
|
||||
assert_eq!(values[12]["value"], true);
|
||||
}
|
||||
|
||||
const WRITER: &str = r#"## main
|
||||
|
||||
**内存 = memory.new(1, 1)**
|
||||
|
||||
**`内存[0] = 65`**
|
||||
|
||||
**`内存[1] = 66`**
|
||||
|
||||
**`内存[2] = 67`**
|
||||
|
||||
**写 = resource.open("file", "out.bin", ["write"])**
|
||||
|
||||
**写入 = resource.write(写, 内存, 0, 3)**
|
||||
|
||||
**关闭写 = resource.close(写)**
|
||||
|
||||
**读 = resource.open("file", "out.bin", ["read"])**
|
||||
|
||||
**读出 = resource.read(读, 内存, 0, 3)**
|
||||
|
||||
**关闭读 = resource.close(读)**
|
||||
|
||||
*[写入.value.count, 关闭写.ok, 读出.value.count, 读出.value.eof, 内存[0], 内存[1], 内存[2], 关闭读.ok]*
|
||||
"#;
|
||||
|
||||
#[test]
|
||||
fn project_file_stream_writes_on_close_then_reads_back() {
|
||||
let dir = TempDir::new("file-write");
|
||||
write_file(&dir.path().join("index.mq.md"), WRITER);
|
||||
let output = cli(
|
||||
dir.path(),
|
||||
&[
|
||||
"run",
|
||||
"index.mq.md",
|
||||
"--allow-write",
|
||||
"out.bin",
|
||||
"--allow-read",
|
||||
"out.bin",
|
||||
"--json",
|
||||
],
|
||||
);
|
||||
assert_eq!(
|
||||
output.status.code(),
|
||||
Some(0),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
let report: serde_json::Value = serde_json::from_slice(&output.stdout).expect("json output");
|
||||
assert_eq!(report["success"], true);
|
||||
let values = report["value"]["items"].as_array().expect("list result");
|
||||
assert_eq!(values[0]["decimal"], "3");
|
||||
assert_eq!(values[1]["value"], true);
|
||||
assert_eq!(values[2]["decimal"], "3");
|
||||
assert_eq!(values[3]["value"], true);
|
||||
assert_eq!(values[4]["decimal"], "65");
|
||||
assert_eq!(values[5]["decimal"], "66");
|
||||
assert_eq!(values[6]["decimal"], "67");
|
||||
assert_eq!(values[7]["value"], true);
|
||||
assert_eq!(std::fs::read(dir.path().join("out.bin")).unwrap(), b"ABC");
|
||||
}
|
||||
|
||||
const COPY: &str = r#"## main
|
||||
|
||||
**输入 = resource.open("file", "data.txt", ["read"])**
|
||||
|
||||
**输出 = resource.open("file", "out.bin", ["write"])**
|
||||
|
||||
**内存 = memory.new(1, 1)**
|
||||
|
||||
**总数 = 0**
|
||||
|
||||
**继续 = true**
|
||||
|
||||
- `继续`
|
||||
|
||||
**块 = resource.read(输入, 内存, 0, 16)**
|
||||
|
||||
1. `块.ok`
|
||||
|
||||
> resource.write(输出, 内存, 0, 块.value.count)
|
||||
|
||||
**总数 = 总数 + 块.value.count**
|
||||
|
||||
**继续 = not 块.value.eof**
|
||||
|
||||
2. `true`
|
||||
|
||||
**继续 = false**
|
||||
|
||||
**关闭读 = resource.close(输入)**
|
||||
|
||||
**关闭写 = resource.close(输出)**
|
||||
|
||||
*[总数, 关闭读.ok, 关闭写.ok]*
|
||||
"#;
|
||||
|
||||
#[test]
|
||||
fn file_copy_is_written_in_mqmd_through_chunked_streams() {
|
||||
let dir = TempDir::new("file-copy");
|
||||
write_file(&dir.path().join("data.txt"), "abcdef");
|
||||
write_file(&dir.path().join("index.mq.md"), COPY);
|
||||
let output = cli(
|
||||
dir.path(),
|
||||
&[
|
||||
"run",
|
||||
"index.mq.md",
|
||||
"--allow-read",
|
||||
"data.txt",
|
||||
"--allow-write",
|
||||
"out.bin",
|
||||
"--json",
|
||||
],
|
||||
);
|
||||
assert_eq!(
|
||||
output.status.code(),
|
||||
Some(0),
|
||||
"{}",
|
||||
String::from_utf8_lossy(&output.stderr)
|
||||
);
|
||||
let report: serde_json::Value = serde_json::from_slice(&output.stdout).expect("json output");
|
||||
assert_eq!(report["success"], true);
|
||||
let values = report["value"]["items"].as_array().expect("list result");
|
||||
assert_eq!(values[0]["decimal"], "6");
|
||||
assert_eq!(values[1]["value"], true);
|
||||
assert_eq!(values[2]["value"], true);
|
||||
assert_eq!(
|
||||
std::fs::read(dir.path().join("out.bin")).unwrap(),
|
||||
b"abcdef"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn file_stream_requires_a_read_grant() {
|
||||
let dir = TempDir::new("file-denied");
|
||||
write_file(&dir.path().join("data.txt"), "abcdef");
|
||||
write_file(&dir.path().join("index.mq.md"), READER);
|
||||
let output = cli(dir.path(), &["run", "index.mq.md", "--json"]);
|
||||
assert_eq!(output.status.code(), Some(1));
|
||||
let report: serde_json::Value = serde_json::from_slice(&output.stdout).expect("json output");
|
||||
assert_eq!(report["success"], false);
|
||||
assert_eq!(report["error"]["code"], "permission.denied");
|
||||
}
|
||||
@@ -195,15 +195,50 @@ impl Expr {
|
||||
}
|
||||
}
|
||||
|
||||
/// The payload of a statement.
|
||||
/// The writable target on the left of `=` (ADR-0022).
|
||||
///
|
||||
/// v1 accepted only [`AssignTarget::Local`]. RFC-CM-0001 adds the second
|
||||
/// variant because addressable `Memory` needs a writable place; no other
|
||||
/// collection becomes mutable. Both variants use the same assignment syntax
|
||||
/// and the same statement position.
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
pub enum StatementKind {
|
||||
/// `<bare identifier> = <expression>`; the only assignment form in v1.
|
||||
Assign {
|
||||
#[serde(tag = "place", rename_all = "snake_case")]
|
||||
pub enum AssignTarget {
|
||||
/// `name = value`: rebind a local slot in the current frame.
|
||||
Local {
|
||||
/// Assigned identifier.
|
||||
name: String,
|
||||
/// Span of the identifier token (not the whole assignment).
|
||||
name_span: Span,
|
||||
},
|
||||
/// `base[index] = value`: write one byte into an addressable `Memory`.
|
||||
Index {
|
||||
/// Base expression, evaluated first.
|
||||
base: Box<Expr>,
|
||||
/// Index expression, evaluated second.
|
||||
index: Box<Expr>,
|
||||
/// Span from the base start through the closing `]`.
|
||||
span: Span,
|
||||
},
|
||||
}
|
||||
|
||||
impl AssignTarget {
|
||||
/// Best known source span of the assignment target.
|
||||
pub fn span(&self) -> Span {
|
||||
match self {
|
||||
AssignTarget::Local { name_span, .. } => *name_span,
|
||||
AssignTarget::Index { span, .. } => *span,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// The payload of a statement.
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
pub enum StatementKind {
|
||||
/// `target = expression`; see [`AssignTarget`] for the writable places.
|
||||
Assign {
|
||||
/// Assigned place.
|
||||
target: AssignTarget,
|
||||
/// Right-hand side expression.
|
||||
value: Expr,
|
||||
},
|
||||
|
||||
@@ -36,8 +36,8 @@
|
||||
//! The grammar is frozen in `spec/expression.ebnf`. In order of decreasing
|
||||
//! precedence: prefix `not` / `-` / `+`, `**` (right associative), postfix
|
||||
//! calls `.name` / `[index]`, `* / // %`, `+ -`, a single non-associative
|
||||
//! comparison, `and`, `or`. Assignment is only available at statement start
|
||||
//! and only for a bare identifier target.
|
||||
//! comparison, `and`, `or`. Assignment is only available at statement start;
|
||||
//! its target is a bare identifier or an index expression (`m[8] = 42`).
|
||||
//!
|
||||
//! Notable lexical rules:
|
||||
//!
|
||||
@@ -84,7 +84,9 @@ use std::fmt;
|
||||
|
||||
use serde::Serialize;
|
||||
|
||||
pub use ast::{Arg, BinaryOp, Expr, Ident, RecordEntry, Statement, StatementKind, UnaryOp};
|
||||
pub use ast::{
|
||||
Arg, AssignTarget, BinaryOp, Expr, Ident, RecordEntry, Statement, StatementKind, UnaryOp,
|
||||
};
|
||||
pub use marqdo_span::Span;
|
||||
pub use parser::MAX_NESTING_DEPTH;
|
||||
|
||||
|
||||
@@ -17,7 +17,9 @@
|
||||
//! recursing into any sub-expression so adversarial inputs fail with a
|
||||
//! structured [`ParseError`] instead of overflowing the stack.
|
||||
|
||||
use crate::ast::{Arg, BinaryOp, Expr, Ident, RecordEntry, Statement, StatementKind, UnaryOp};
|
||||
use crate::ast::{
|
||||
Arg, AssignTarget, BinaryOp, Expr, Ident, RecordEntry, Statement, StatementKind, UnaryOp,
|
||||
};
|
||||
use crate::lexer::{self, Token, TokenKind};
|
||||
use crate::ParseError;
|
||||
use marqdo_span::Span;
|
||||
@@ -47,21 +49,16 @@ pub(crate) fn parse_statement(source: &str) -> Result<Statement, ParseError> {
|
||||
return Err(parser.error_here("expected a statement, found end of input"));
|
||||
}
|
||||
let start = parser.peek().span.start;
|
||||
if let TokenKind::Ident(_) = parser.peek().kind {
|
||||
if matches!(
|
||||
parser.peek_n(1).map(|token| &token.kind),
|
||||
Some(TokenKind::Assign)
|
||||
) {
|
||||
return parser.assignment(start);
|
||||
}
|
||||
let left = parser.expression()?;
|
||||
if matches!(parser.peek().kind, TokenKind::Assign) {
|
||||
return parser.assignment(start, left);
|
||||
}
|
||||
let expr = parser.expression()?;
|
||||
if !parser.at_eof() {
|
||||
return Err(parser.trailing_statement_error(&expr));
|
||||
return Err(parser.trailing_statement_error());
|
||||
}
|
||||
let end = parser.previous_end();
|
||||
Ok(Statement {
|
||||
kind: StatementKind::Expr(expr),
|
||||
kind: StatementKind::Expr(left),
|
||||
span: Span::new(start, end),
|
||||
})
|
||||
}
|
||||
@@ -201,11 +198,8 @@ impl Parser {
|
||||
// Statements
|
||||
// ------------------------------------------------------------------
|
||||
|
||||
fn assignment(&mut self, start: usize) -> Result<Statement, ParseError> {
|
||||
let TokenKind::Ident(name) = self.peek().kind.clone() else {
|
||||
return Err(self.error_here("expected an identifier on the left of `=`"));
|
||||
};
|
||||
let name_token = self.bump();
|
||||
fn assignment(&mut self, start: usize, left: Expr) -> Result<Statement, ParseError> {
|
||||
let target = self.assign_target(left)?;
|
||||
self.bump(); // `=`
|
||||
if self.at_eof() {
|
||||
return Err(self.error_here("expected an expression after `=`"));
|
||||
@@ -226,29 +220,40 @@ impl Parser {
|
||||
}
|
||||
let end = self.previous_end();
|
||||
Ok(Statement {
|
||||
kind: StatementKind::Assign {
|
||||
name,
|
||||
name_span: name_token.span,
|
||||
value,
|
||||
},
|
||||
kind: StatementKind::Assign { target, value },
|
||||
span: Span::new(start, end),
|
||||
})
|
||||
}
|
||||
|
||||
fn trailing_statement_error(&self, expr: &Expr) -> ParseError {
|
||||
if matches!(self.peek().kind, TokenKind::Assign) {
|
||||
return if matches!(expr, Expr::Member { .. } | Expr::Index { .. }) {
|
||||
self.error_here(
|
||||
"invalid assignment target: member and index assignment are not supported \
|
||||
in v1; assign a bare identifier",
|
||||
)
|
||||
} else {
|
||||
self.error_here(
|
||||
"invalid assignment target: assignment requires a bare identifier on the \
|
||||
left of `=`",
|
||||
)
|
||||
};
|
||||
/// Turn the already-parsed left expression into a writable target.
|
||||
///
|
||||
/// v1 only writes local slots. Addressable `Memory` adds index targets;
|
||||
/// member assignment and every other shape stay hard parse errors so an
|
||||
/// invalid executable shape never silently becomes prose (ADR-0022).
|
||||
fn assign_target(&self, left: Expr) -> Result<AssignTarget, ParseError> {
|
||||
match left {
|
||||
Expr::Ident(Ident { name, span }) => Ok(AssignTarget::Local {
|
||||
name,
|
||||
name_span: span,
|
||||
}),
|
||||
Expr::Index { base, index, span } => Ok(AssignTarget::Index { base, index, span }),
|
||||
Expr::Member { span, .. } => Err(ParseError::new(
|
||||
span,
|
||||
"member assignment is not supported in v1; only a local name or a \
|
||||
Memory index is writable",
|
||||
)),
|
||||
other => Err(ParseError::new(
|
||||
other.span(),
|
||||
format!(
|
||||
"invalid assignment target: {} is not a writable place; assign a local \
|
||||
name or a Memory index",
|
||||
describe_expr(&other)
|
||||
),
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
fn trailing_statement_error(&self) -> ParseError {
|
||||
self.error_here(format!(
|
||||
"unexpected {} after expression",
|
||||
self.describe_current()
|
||||
@@ -705,6 +710,24 @@ fn is_keyword(kind: &TokenKind) -> bool {
|
||||
)
|
||||
}
|
||||
|
||||
fn describe_expr(expr: &Expr) -> &'static str {
|
||||
match expr {
|
||||
Expr::Int(_) => "an integer literal",
|
||||
Expr::Float(_) => "a float literal",
|
||||
Expr::Text(_) => "a text literal",
|
||||
Expr::Bool(_) => "a boolean literal",
|
||||
Expr::None => "`None`",
|
||||
Expr::Ident(_) => "an identifier",
|
||||
Expr::List(_) => "a list literal",
|
||||
Expr::Record(_) => "a record literal",
|
||||
Expr::Unary { .. } => "a unary expression",
|
||||
Expr::Binary { .. } => "a binary expression",
|
||||
Expr::Call { .. } => "a call expression",
|
||||
Expr::Member { .. } => "a member access",
|
||||
Expr::Index { .. } => "an index expression",
|
||||
}
|
||||
}
|
||||
|
||||
fn describe_token(kind: &TokenKind) -> String {
|
||||
match kind {
|
||||
TokenKind::Int(raw) => format!("integer literal `{raw}`"),
|
||||
@@ -1154,14 +1177,19 @@ mod tests {
|
||||
assert_eq!(
|
||||
stmt.kind,
|
||||
StatementKind::Assign {
|
||||
name: "x".to_owned(),
|
||||
name_span: Span::new(0, 1),
|
||||
target: AssignTarget::Local {
|
||||
name: "x".to_owned(),
|
||||
name_span: Span::new(0, 1),
|
||||
},
|
||||
value: Expr::Int(BigInt::from(1)),
|
||||
}
|
||||
);
|
||||
let stmt = st("结果 = 阶乘(n=3)");
|
||||
match &stmt.kind {
|
||||
StatementKind::Assign { name, value, .. } => {
|
||||
StatementKind::Assign {
|
||||
target: AssignTarget::Local { name, .. },
|
||||
value,
|
||||
} => {
|
||||
assert_eq!(name, "结果");
|
||||
assert_eq!(sexpr(value), "(call 阶乘 n=3)");
|
||||
}
|
||||
@@ -1170,6 +1198,40 @@ mod tests {
|
||||
assert_eq!(st("x = y + 1").span(), Span::new(0, 9));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn memory_index_assignment_parses_as_a_place() {
|
||||
let stmt = st("m[8] = 42");
|
||||
let StatementKind::Assign { target, value } = &stmt.kind else {
|
||||
panic!("expected assignment, got {:?}", stmt.kind);
|
||||
};
|
||||
let AssignTarget::Index { base, index, span } = target else {
|
||||
panic!("expected index target, got {target:?}");
|
||||
};
|
||||
assert_eq!(
|
||||
**base,
|
||||
Expr::Ident(Ident {
|
||||
name: "m".to_owned(),
|
||||
span: Span::new(0, 1),
|
||||
})
|
||||
);
|
||||
assert_eq!(**index, Expr::Int(BigInt::from(8)));
|
||||
assert_eq!(*span, Span::new(0, 4));
|
||||
assert_eq!(*value, Expr::Int(BigInt::from(42)));
|
||||
assert_eq!(stmt.span, Span::new(0, 9));
|
||||
|
||||
// Nested targets are syntactically places; the runtime decides whether
|
||||
// the base value is a writable Memory region.
|
||||
let stmt = st("outer[0][1] = 2");
|
||||
let StatementKind::Assign {
|
||||
target: AssignTarget::Index { base, .. },
|
||||
..
|
||||
} = &stmt.kind
|
||||
else {
|
||||
panic!("expected nested index target, got {:?}", stmt.kind);
|
||||
};
|
||||
assert!(matches!(base.as_ref(), Expr::Index { .. }));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn expression_statements_parse() {
|
||||
assert_eq!(st("打印(1)").kind, StatementKind::Expr(ex("打印(1)")));
|
||||
@@ -1185,8 +1247,8 @@ mod tests {
|
||||
"x =",
|
||||
"x = 1 = 2",
|
||||
"a.b = 1",
|
||||
"a[0] = 1",
|
||||
"1 = 2",
|
||||
"f() = 1",
|
||||
"= 1",
|
||||
"x = 1 2",
|
||||
] {
|
||||
@@ -1194,7 +1256,8 @@ mod tests {
|
||||
assert_eq!(err.code, "expr.parse", "input {bad:?}");
|
||||
}
|
||||
assert!(st_err("x = 1 = 2").message.contains("chained assignment"));
|
||||
assert!(st_err("a.b = 1").message.contains("member and index"));
|
||||
assert!(st_err("a.b = 1").message.contains("member assignment"));
|
||||
assert!(st_err("1 = 2").message.contains("writable place"));
|
||||
assert!(st_err("x =").message.contains("after `=`"));
|
||||
}
|
||||
|
||||
@@ -1228,7 +1291,10 @@ mod tests {
|
||||
let stmt = st(" x = 1 ");
|
||||
assert_eq!(stmt.span(), Span::new(2, 7));
|
||||
match stmt.kind {
|
||||
StatementKind::Assign { name_span, .. } => assert_eq!(name_span, Span::new(2, 3)),
|
||||
StatementKind::Assign {
|
||||
target: AssignTarget::Local { name_span, .. },
|
||||
..
|
||||
} => assert_eq!(name_span, Span::new(2, 3)),
|
||||
other => panic!("expected assignment, got {other:?}"),
|
||||
}
|
||||
|
||||
|
||||
@@ -8,7 +8,7 @@
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
use marqdo_expression::{Arg, Expr, Ident};
|
||||
use marqdo_ir::{builtins, Module, ModuleId, Param, Program, SignatureKind, Stmt};
|
||||
use marqdo_ir::{builtins, Module, ModuleId, Param, PlaceTarget, Program, SignatureKind, Stmt};
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{codes, Diagnostic};
|
||||
|
||||
@@ -109,7 +109,10 @@ pub fn validate_program(program: &Program) -> Vec<(ModuleId, Diagnostic)> {
|
||||
fn collect_assigned(stmts: &[Stmt], out: &mut BTreeSet<String>) {
|
||||
for stmt in stmts {
|
||||
match stmt {
|
||||
Stmt::Assign { name, .. } => {
|
||||
Stmt::Assign {
|
||||
target: PlaceTarget::Local { name, .. },
|
||||
..
|
||||
} => {
|
||||
out.insert(name.clone());
|
||||
}
|
||||
Stmt::Branch { arms, .. } => {
|
||||
@@ -138,9 +141,14 @@ impl<'a> CallChecker<'a> {
|
||||
fn stmts(&mut self, stmts: &[Stmt]) {
|
||||
for stmt in stmts {
|
||||
match stmt {
|
||||
Stmt::Assign { value, .. }
|
||||
| Stmt::Eval { expr: value, .. }
|
||||
| Stmt::Return { value, .. } => {
|
||||
Stmt::Assign { target, value, .. } => {
|
||||
if let PlaceTarget::Index { base, index, .. } = target {
|
||||
self.expr(base);
|
||||
self.expr(index);
|
||||
}
|
||||
self.expr(value);
|
||||
}
|
||||
Stmt::Eval { expr: value, .. } | Stmt::Return { value, .. } => {
|
||||
self.expr(value);
|
||||
}
|
||||
Stmt::Call { call, .. } => {
|
||||
|
||||
@@ -17,7 +17,7 @@
|
||||
use std::collections::{BTreeMap, BTreeSet};
|
||||
|
||||
use marqdo_expression::{Arg, Expr, Ident, RecordEntry};
|
||||
use marqdo_ir::{BranchArm, Stmt};
|
||||
use marqdo_ir::{BranchArm, PlaceTarget, Stmt};
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{codes, Diagnostic};
|
||||
|
||||
@@ -178,9 +178,24 @@ impl<'a> Analyzer<'a> {
|
||||
fn analyze_stmts(&mut self, stmts: &[Stmt], mut state: State) -> State {
|
||||
for stmt in stmts {
|
||||
state = match stmt {
|
||||
Stmt::Assign { name, value, .. } => {
|
||||
self.read_expr(value, &state);
|
||||
self.assign(name, &mut state);
|
||||
Stmt::Assign { target, value, .. } => {
|
||||
match target {
|
||||
PlaceTarget::Local { name, .. } => {
|
||||
// Preserve v1 order: the RHS is read before the
|
||||
// local rebinding makes the name definitely
|
||||
// assigned.
|
||||
self.read_expr(value, &state);
|
||||
self.assign(name, &mut state);
|
||||
}
|
||||
PlaceTarget::Index { base, index, .. } => {
|
||||
// Runtime order for an index place is base, index,
|
||||
// RHS; reads in the place are free reads like any
|
||||
// other.
|
||||
self.read_expr(base, &state);
|
||||
self.read_expr(index, &state);
|
||||
self.read_expr(value, &state);
|
||||
}
|
||||
}
|
||||
state
|
||||
}
|
||||
Stmt::Eval { expr, .. } => {
|
||||
@@ -312,8 +327,10 @@ mod tests {
|
||||
|
||||
fn assign(name: &str, value: &str) -> Stmt {
|
||||
Stmt::Assign {
|
||||
name: name.to_string(),
|
||||
name_span: Span::new(0, 0),
|
||||
target: PlaceTarget::Local {
|
||||
name: name.to_string(),
|
||||
name_span: Span::new(0, 0),
|
||||
},
|
||||
value: parse_expression(value).unwrap(),
|
||||
span: Span::new(0, 0),
|
||||
}
|
||||
@@ -334,6 +351,24 @@ mod tests {
|
||||
.collect()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn index_assignment_reads_its_base_and_index_without_binding_a_local() {
|
||||
let stmts = vec![
|
||||
Stmt::Assign {
|
||||
target: PlaceTarget::Index {
|
||||
base: parse_expression("m").unwrap(),
|
||||
index: parse_expression("i").unwrap(),
|
||||
span: Span::new(0, 0),
|
||||
},
|
||||
value: parse_expression("9").unwrap(),
|
||||
span: Span::new(0, 0),
|
||||
},
|
||||
ret("m[0]"),
|
||||
];
|
||||
// `m` and `i` are free reads; the place never rebinds `m` as a local.
|
||||
assert_eq!(params(&stmts), vec!["i".to_string(), "m".to_string()]);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn infers_free_reads() {
|
||||
// n * 阶乘(n=n-1)
|
||||
|
||||
@@ -6,9 +6,9 @@
|
||||
//! diagnostics and never fall back to prose.
|
||||
|
||||
use marqdo_expression::{
|
||||
parse_arguments, parse_expression, parse_statement, Arg, Expr, StatementKind,
|
||||
parse_arguments, parse_expression, parse_statement, Arg, AssignTarget, Expr, StatementKind,
|
||||
};
|
||||
use marqdo_ir::{CallSite, CallTarget, ImportDecl, Stmt};
|
||||
use marqdo_ir::{CallSite, CallTarget, ImportDecl, PlaceTarget, Stmt};
|
||||
use marqdo_markdown::{normalize_name, MarkdownDocument, MdKind, MdNode};
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{codes, Diagnostic};
|
||||
@@ -143,13 +143,21 @@ impl<'a> Mapper<'a> {
|
||||
Ok(mut statement) => {
|
||||
segments.rewrite_statement(&mut statement);
|
||||
Some(match statement.kind {
|
||||
StatementKind::Assign {
|
||||
name,
|
||||
name_span,
|
||||
value,
|
||||
} => Stmt::Assign {
|
||||
name,
|
||||
name_span,
|
||||
StatementKind::Assign { target, value } => Stmt::Assign {
|
||||
target: match target {
|
||||
AssignTarget::Local { name, name_span } => {
|
||||
PlaceTarget::Local { name, name_span }
|
||||
}
|
||||
AssignTarget::Index {
|
||||
base,
|
||||
index,
|
||||
span: target_span,
|
||||
} => PlaceTarget::Index {
|
||||
base: *base,
|
||||
index: *index,
|
||||
span: target_span,
|
||||
},
|
||||
},
|
||||
value,
|
||||
span: node.span,
|
||||
},
|
||||
|
||||
@@ -5,7 +5,7 @@
|
||||
//! string, so its spans are payload-relative; this module maps them back to the
|
||||
//! original file so diagnostics point at real source.
|
||||
|
||||
use marqdo_expression::{Arg, Expr, RecordEntry, Statement, StatementKind};
|
||||
use marqdo_expression::{Arg, AssignTarget, Expr, RecordEntry, Statement, StatementKind};
|
||||
use marqdo_markdown::{MdKind, MdNode, PayloadError};
|
||||
use marqdo_span::Span;
|
||||
|
||||
@@ -140,11 +140,17 @@ impl PayloadSegments {
|
||||
/// Map and rewrite every span in a parsed statement.
|
||||
pub fn rewrite_statement(&self, statement: &mut Statement) {
|
||||
statement.span = self.map_span(statement.span);
|
||||
if let StatementKind::Assign {
|
||||
name_span, value, ..
|
||||
} = &mut statement.kind
|
||||
{
|
||||
*name_span = self.map_span(*name_span);
|
||||
if let StatementKind::Assign { target, value } = &mut statement.kind {
|
||||
match target {
|
||||
AssignTarget::Local { name_span, .. } => {
|
||||
*name_span = self.map_span(*name_span);
|
||||
}
|
||||
AssignTarget::Index { base, index, span } => {
|
||||
*span = self.map_span(*span);
|
||||
self.rewrite_expr(base);
|
||||
self.rewrite_expr(index);
|
||||
}
|
||||
}
|
||||
self.rewrite_expr(value);
|
||||
}
|
||||
if let StatementKind::Expr(expr) = &mut statement.kind {
|
||||
|
||||
@@ -83,6 +83,22 @@ impl ProjectFs {
|
||||
|
||||
/// Read a UTF-8 file, bounded by [`MAX_READ_BYTES`].
|
||||
pub fn read(&self, user_path: &str, span: Option<Span>) -> Result<String, RuntimeError> {
|
||||
let bytes = self.read_bytes(user_path, span)?;
|
||||
String::from_utf8(bytes).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::Type,
|
||||
span,
|
||||
format!("`{user_path}` is not valid UTF-8"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Read a file as raw bytes, bounded by [`MAX_READ_BYTES`].
|
||||
///
|
||||
/// Used by the resource stream provider; path/capability checks are the
|
||||
/// caller's responsibility for grants, while this method still rejects
|
||||
/// traversal and symlink escapes.
|
||||
pub fn read_bytes(&self, user_path: &str, span: Option<Span>) -> Result<Vec<u8>, RuntimeError> {
|
||||
let (absolute, relative) = self.resolve(user_path, span)?;
|
||||
let metadata = std::fs::metadata(&absolute).map_err(|error| {
|
||||
RuntimeError::new(
|
||||
@@ -118,19 +134,12 @@ impl ProjectFs {
|
||||
if !canonical.starts_with(&self.root) {
|
||||
return Err(invalid_path(span, "path escapes the project root"));
|
||||
}
|
||||
let bytes = std::fs::read(&canonical).map_err(|error| {
|
||||
std::fs::read(&canonical).map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
format!("cannot read `{relative}`: {error}"),
|
||||
)
|
||||
})?;
|
||||
String::from_utf8(bytes).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::Type,
|
||||
span,
|
||||
format!("`{relative}` is not valid UTF-8"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
@@ -140,6 +149,18 @@ impl ProjectFs {
|
||||
user_path: &str,
|
||||
contents: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
self.write_bytes(user_path, contents.as_bytes(), span)
|
||||
}
|
||||
|
||||
/// Write raw bytes inside the project root, creating parent directories.
|
||||
///
|
||||
/// This is a single validated write, not a transactional replace.
|
||||
pub fn write_bytes(
|
||||
&self,
|
||||
user_path: &str,
|
||||
bytes: &[u8],
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let (absolute, relative) = self.resolve(user_path, span)?;
|
||||
// Validate the closest existing ancestor stays inside the root.
|
||||
@@ -169,7 +190,7 @@ impl ProjectFs {
|
||||
)
|
||||
})?;
|
||||
}
|
||||
std::fs::write(&absolute, contents).map_err(|error| {
|
||||
std::fs::write(&absolute, bytes).map_err(|error| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::HostError,
|
||||
span,
|
||||
|
||||
@@ -12,7 +12,7 @@ use marqdo_plugin_abi::{
|
||||
ErrorKind as PluginErrorKind, LoadedPlugin, PluginError, PluginKind, PluginManifest,
|
||||
};
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{ErrorCategory, RuntimeError, Value};
|
||||
use marqdo_value::{ErrorCategory, ResourceHandle, RuntimeError, Value};
|
||||
|
||||
use crate::budget::Budget;
|
||||
use crate::capability::{Capabilities, CapabilityAudit, CapabilityBroker};
|
||||
@@ -20,6 +20,7 @@ use crate::context::ExecutionContext;
|
||||
use crate::fs::ProjectFs;
|
||||
use crate::handles::{contains_plugin_handle, PluginHandleTable};
|
||||
use crate::plugin_worker::WorkerPlugin;
|
||||
use crate::resource::{ResourceRead, ResourceTable};
|
||||
use crate::trace::{EffectTrace, SemanticEvent, TraceBudget, TraceEntry, TraceState};
|
||||
use marqdo_sandbox::{PlatformCapabilities, SandboxMode};
|
||||
|
||||
@@ -79,6 +80,65 @@ pub trait Host {
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<Value, RuntimeError>;
|
||||
|
||||
/// Open a resource/stream by kind, descriptor and requested rights.
|
||||
///
|
||||
/// Default: unavailable. Only the standard host implements the first
|
||||
/// resource kinds (ADR-0025).
|
||||
fn resource_open(
|
||||
&mut self,
|
||||
_kind: &str,
|
||||
_descriptor: &str,
|
||||
_rights: &[String],
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
"this host does not provide resource streams",
|
||||
))
|
||||
}
|
||||
|
||||
/// Read up to `max_bytes` from a resource into host memory.
|
||||
fn resource_read(
|
||||
&mut self,
|
||||
_handle: ResourceHandle,
|
||||
_max_bytes: usize,
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<ResourceRead, RuntimeError> {
|
||||
Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
"this host does not provide resource streams",
|
||||
))
|
||||
}
|
||||
|
||||
/// Write bytes to a resource; returns the accepted count.
|
||||
fn resource_write(
|
||||
&mut self,
|
||||
_handle: ResourceHandle,
|
||||
_bytes: &[u8],
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
"this host does not provide resource streams",
|
||||
))
|
||||
}
|
||||
|
||||
/// Close a resource handle.
|
||||
fn resource_close(
|
||||
&mut self,
|
||||
_handle: ResourceHandle,
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<(), RuntimeError> {
|
||||
Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
"this host does not provide resource streams",
|
||||
))
|
||||
}
|
||||
|
||||
/// Consume evaluation fuel.
|
||||
fn consume_fuel(&mut self, amount: u64, span: Option<Span>) -> Result<(), RuntimeError>;
|
||||
|
||||
@@ -143,6 +203,8 @@ pub struct StdHost {
|
||||
broker_audit: Arc<Mutex<Vec<CapabilityAudit>>>,
|
||||
/// Host-issued opaque plugin handles.
|
||||
pub handles: PluginHandleTable,
|
||||
/// Host-owned resource/stream table (ADR-0025).
|
||||
resources: ResourceTable,
|
||||
semantic_events: Vec<SemanticEvent>,
|
||||
next_event_seq: u64,
|
||||
trace_state: TraceState,
|
||||
@@ -203,6 +265,7 @@ impl StdHost {
|
||||
vendor_capabilities: BTreeSet::new(),
|
||||
broker_audit: Arc::new(Mutex::new(Vec::new())),
|
||||
handles: PluginHandleTable::default(),
|
||||
resources: ResourceTable::new(),
|
||||
semantic_events: Vec::new(),
|
||||
next_event_seq: 0,
|
||||
trace_state: TraceState::default(),
|
||||
@@ -526,6 +589,96 @@ impl StdHost {
|
||||
self.fs.write(&path, &contents, ctx.span)?;
|
||||
Ok(Value::Unit)
|
||||
}
|
||||
|
||||
fn open_resource_stream(
|
||||
&mut self,
|
||||
kind: &str,
|
||||
descriptor: &str,
|
||||
rights: &[String],
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
if self.mode == SandboxMode::Strict {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::PermissionDenied,
|
||||
ctx.span,
|
||||
"resource streams are not verified in strict mode and are refused",
|
||||
));
|
||||
}
|
||||
if self.mode == SandboxMode::Pure && kind == "file" {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::PermissionDenied,
|
||||
ctx.span,
|
||||
"pure mode does not provide project file resources",
|
||||
));
|
||||
}
|
||||
let requested: BTreeSet<&str> = rights.iter().map(String::as_str).collect();
|
||||
match kind {
|
||||
"stdio" => {
|
||||
if descriptor != "stdout" || requested != BTreeSet::from(["write"]) {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
"the first stream slice supports only stdio/stdout with rights [write]",
|
||||
));
|
||||
}
|
||||
if !self.capabilities.console {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::PermissionDenied,
|
||||
ctx.span,
|
||||
"the console capability is required for stdio/stdout",
|
||||
));
|
||||
}
|
||||
let handle = self.resources.open_stdout();
|
||||
self.record_semantic(
|
||||
"resource.open",
|
||||
None,
|
||||
Some(&ctx.module_id),
|
||||
ctx.span,
|
||||
Some("kind=stdio descriptor=stdout"),
|
||||
);
|
||||
Ok(Value::Resource(handle))
|
||||
}
|
||||
"file" => {
|
||||
if requested == BTreeSet::from(["read"]) {
|
||||
self.capabilities.check_read(descriptor, ctx.span)?;
|
||||
let (_, relative) = self.fs.resolve(descriptor, ctx.span)?;
|
||||
let bytes = self.fs.read_bytes(descriptor, ctx.span)?;
|
||||
let handle = self.resources.open_file(relative, bytes);
|
||||
self.record_semantic(
|
||||
"resource.open",
|
||||
None,
|
||||
Some(&ctx.module_id),
|
||||
ctx.span,
|
||||
Some("kind=file rights=read"),
|
||||
);
|
||||
return Ok(Value::Resource(handle));
|
||||
}
|
||||
if requested == BTreeSet::from(["write"]) {
|
||||
self.capabilities.check_write(descriptor, ctx.span)?;
|
||||
let (_, relative) = self.fs.resolve(descriptor, ctx.span)?;
|
||||
let handle = self.resources.open_file_writer(relative);
|
||||
self.record_semantic(
|
||||
"resource.open",
|
||||
None,
|
||||
Some(&ctx.module_id),
|
||||
ctx.span,
|
||||
Some("kind=file rights=write"),
|
||||
);
|
||||
return Ok(Value::Resource(handle));
|
||||
}
|
||||
Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
"project file streams support exactly [read] or [write] in this build",
|
||||
))
|
||||
}
|
||||
other => Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
ctx.span,
|
||||
format!("resource kind `{other}` is not implemented in this build"),
|
||||
)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Host for StdHost {
|
||||
@@ -535,6 +688,31 @@ impl Host for StdHost {
|
||||
args: Vec<Value>,
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
// Addressable memory is language-local state. Handles must not reach a
|
||||
// plugin, foreign kernel or file adapter, where they could not be
|
||||
// interpreted safely (RFC-CM-0001 §8, ADR-0022 §4).
|
||||
if args.iter().any(Value::contains_memory) {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::Type,
|
||||
ctx.span,
|
||||
format!(
|
||||
"Memory values cannot cross the host boundary (`{}`); copy bytes into \
|
||||
Text explicitly first",
|
||||
op.name()
|
||||
),
|
||||
));
|
||||
}
|
||||
if args.iter().any(Value::contains_resource) {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::Type,
|
||||
ctx.span,
|
||||
format!(
|
||||
"Resource handles cannot cross the generic host boundary (`{}`); use \
|
||||
resource.* operations",
|
||||
op.name()
|
||||
),
|
||||
));
|
||||
}
|
||||
let started = Instant::now();
|
||||
let result = self.dispatch(op, args, ctx);
|
||||
let summary = match &result {
|
||||
@@ -562,6 +740,84 @@ impl Host for StdHost {
|
||||
result
|
||||
}
|
||||
|
||||
fn resource_open(
|
||||
&mut self,
|
||||
kind: &str,
|
||||
descriptor: &str,
|
||||
rights: &[String],
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
self.open_resource_stream(kind, descriptor, rights, ctx)
|
||||
}
|
||||
|
||||
fn resource_read(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
max_bytes: usize,
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<ResourceRead, RuntimeError> {
|
||||
let kind = self.resources.kind(handle, ctx.span)?;
|
||||
let read = self.resources.read(handle, max_bytes, ctx.span)?;
|
||||
self.record_semantic(
|
||||
"resource.read",
|
||||
None,
|
||||
Some(&ctx.module_id),
|
||||
ctx.span,
|
||||
Some(&format!(
|
||||
"kind={kind} count={} eof={}",
|
||||
read.bytes.len(),
|
||||
read.eof
|
||||
)),
|
||||
);
|
||||
Ok(read)
|
||||
}
|
||||
|
||||
fn resource_write(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
bytes: &[u8],
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
let kind = self.resources.kind(handle, ctx.span)?;
|
||||
let count = self.resources.write(handle, bytes, ctx.span)?;
|
||||
if kind == "stdio" {
|
||||
self.budget.consume_output(count, ctx.span)?;
|
||||
self.output.extend_from_slice(bytes);
|
||||
}
|
||||
self.record_semantic(
|
||||
"resource.write",
|
||||
None,
|
||||
Some(&ctx.module_id),
|
||||
ctx.span,
|
||||
Some(&format!("kind={kind} count={count}")),
|
||||
);
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
fn resource_close(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
ctx: &ExecutionContext,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let pending = self.resources.pending_file_write(handle, ctx.span)?;
|
||||
let count = match pending {
|
||||
Some((relative, bytes)) => {
|
||||
self.fs.write_bytes(&relative, &bytes, ctx.span)?;
|
||||
bytes.len()
|
||||
}
|
||||
None => 0,
|
||||
};
|
||||
self.resources.close(handle, ctx.span)?;
|
||||
self.record_semantic(
|
||||
"resource.close",
|
||||
None,
|
||||
Some(&ctx.module_id),
|
||||
ctx.span,
|
||||
Some(&format!("flushed_bytes={count}")),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn consume_fuel(&mut self, amount: u64, span: Option<Span>) -> Result<(), RuntimeError> {
|
||||
self.budget.consume_fuel(amount, span)
|
||||
}
|
||||
|
||||
@@ -12,6 +12,7 @@ pub mod handles;
|
||||
pub mod host;
|
||||
pub mod kernels;
|
||||
mod plugin_worker;
|
||||
pub mod resource;
|
||||
pub mod trace;
|
||||
|
||||
pub use budget::{Budget, DEFAULT_FUEL, DEFAULT_OUTPUT_BYTES, DEFAULT_STACK_LIMIT};
|
||||
@@ -21,4 +22,5 @@ pub use fs::ProjectFs;
|
||||
pub use handles::{contains_plugin_handle, PluginHandleTable};
|
||||
pub use host::{arity, expect_text, Host, HostOp, StdHost};
|
||||
pub use marqdo_sandbox::{PlatformCapabilities, SandboxMode, StrictIsolation};
|
||||
pub use resource::{ResourceRead, ResourceTable};
|
||||
pub use trace::{EffectTrace, SemanticEvent, TraceBudget, TraceEntry, TraceState, TraceTruncation};
|
||||
@@ -0,0 +1,390 @@
|
||||
//! Host-owned resource/stream table (ADR-0025).
|
||||
//!
|
||||
//! The first slice deliberately supports only stdout writes and bounded
|
||||
//! project-file reads loaded at open. Handles are run-scoped and opaque; the
|
||||
//! table validates run identity, slot identity and generation on every call.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{ErrorCategory, ResourceHandle, RuntimeError};
|
||||
|
||||
static NEXT_RUN_ID: AtomicU64 = AtomicU64::new(1);
|
||||
|
||||
/// Bytes returned by one stream read.
|
||||
#[derive(Debug, Clone, PartialEq, Eq)]
|
||||
pub struct ResourceRead {
|
||||
/// Bytes actually read (may be empty at EOF).
|
||||
pub bytes: Vec<u8>,
|
||||
/// Whether the stream has reached EOF.
|
||||
pub eof: bool,
|
||||
}
|
||||
|
||||
enum Stream {
|
||||
Stdout {
|
||||
closed: bool,
|
||||
},
|
||||
File {
|
||||
relative: String,
|
||||
bytes: Vec<u8>,
|
||||
position: usize,
|
||||
closed: bool,
|
||||
},
|
||||
FileWriter {
|
||||
relative: String,
|
||||
bytes: Vec<u8>,
|
||||
closed: bool,
|
||||
},
|
||||
}
|
||||
|
||||
struct Slot {
|
||||
generation: u64,
|
||||
stream: Stream,
|
||||
}
|
||||
|
||||
impl Slot {
|
||||
fn closed(&self) -> bool {
|
||||
match &self.stream {
|
||||
Stream::Stdout { closed } => *closed,
|
||||
Stream::File { closed, .. } => *closed,
|
||||
Stream::FileWriter { closed, .. } => *closed,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Host resource table for one run.
|
||||
pub struct ResourceTable {
|
||||
run_id: u64,
|
||||
next_resource: u64,
|
||||
slots: BTreeMap<u64, Slot>,
|
||||
}
|
||||
|
||||
impl Default for ResourceTable {
|
||||
fn default() -> Self {
|
||||
Self::new()
|
||||
}
|
||||
}
|
||||
|
||||
impl ResourceTable {
|
||||
/// Create an empty table with a fresh run identity.
|
||||
pub fn new() -> Self {
|
||||
Self {
|
||||
run_id: NEXT_RUN_ID.fetch_add(1, Ordering::Relaxed),
|
||||
next_resource: 1,
|
||||
slots: BTreeMap::new(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Number of live (not necessarily open) slots.
|
||||
pub fn slot_count(&self) -> usize {
|
||||
self.slots.len()
|
||||
}
|
||||
|
||||
/// Register the pre-opened stdout stream.
|
||||
pub fn open_stdout(&mut self) -> ResourceHandle {
|
||||
self.insert(Stream::Stdout { closed: false })
|
||||
}
|
||||
|
||||
/// Register a project-file read stream opened from already-bounded bytes.
|
||||
pub fn open_file(&mut self, relative: impl Into<String>, bytes: Vec<u8>) -> ResourceHandle {
|
||||
self.insert(Stream::File {
|
||||
relative: relative.into(),
|
||||
bytes,
|
||||
position: 0,
|
||||
closed: false,
|
||||
})
|
||||
}
|
||||
|
||||
/// Register an empty buffered project-file write stream.
|
||||
pub fn open_file_writer(&mut self, relative: impl Into<String>) -> ResourceHandle {
|
||||
self.insert(Stream::FileWriter {
|
||||
relative: relative.into(),
|
||||
bytes: Vec::new(),
|
||||
closed: false,
|
||||
})
|
||||
}
|
||||
|
||||
fn insert(&mut self, stream: Stream) -> ResourceHandle {
|
||||
let id = self.next_resource;
|
||||
self.next_resource += 1;
|
||||
self.slots.insert(
|
||||
id,
|
||||
Slot {
|
||||
generation: 1,
|
||||
stream,
|
||||
},
|
||||
);
|
||||
ResourceHandle::from_host(self.run_id, id, 1)
|
||||
}
|
||||
|
||||
fn slot(&self, handle: ResourceHandle, span: Option<Span>) -> Result<&Slot, RuntimeError> {
|
||||
if handle.run_id() != self.run_id {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceFault,
|
||||
span,
|
||||
"Resource handle belongs to a different host run",
|
||||
));
|
||||
}
|
||||
let Some(slot) = self.slots.get(&handle.resource_id()) else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceFault,
|
||||
span,
|
||||
"unknown Resource handle",
|
||||
));
|
||||
};
|
||||
if slot.generation != handle.generation() {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceFault,
|
||||
span,
|
||||
"stale Resource handle",
|
||||
));
|
||||
}
|
||||
Ok(slot)
|
||||
}
|
||||
|
||||
fn slot_mut(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
span: Option<Span>,
|
||||
) -> Result<&mut Slot, RuntimeError> {
|
||||
self.slot(handle, span)?;
|
||||
self.slots
|
||||
.get_mut(&handle.resource_id())
|
||||
.ok_or_else(|| unknown_handle(span))
|
||||
}
|
||||
|
||||
/// Read up to `max_bytes` from a file stream.
|
||||
///
|
||||
/// Reads at EOF return `count=0, eof=true`. A read on a closed stream is
|
||||
/// `resource.closed`; stdout is not readable.
|
||||
pub fn read(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
max_bytes: usize,
|
||||
span: Option<Span>,
|
||||
) -> Result<ResourceRead, RuntimeError> {
|
||||
let slot = self.slot_mut(handle, span)?;
|
||||
if slot.closed() {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceClosed,
|
||||
span,
|
||||
"Resource handle is closed",
|
||||
));
|
||||
}
|
||||
match &mut slot.stream {
|
||||
Stream::File {
|
||||
bytes, position, ..
|
||||
} => {
|
||||
let start = *position;
|
||||
let end = start.saturating_add(max_bytes).min(bytes.len());
|
||||
let chunk = bytes[start..end].to_vec();
|
||||
*position = end;
|
||||
Ok(ResourceRead {
|
||||
bytes: chunk,
|
||||
eof: end >= bytes.len(),
|
||||
})
|
||||
}
|
||||
Stream::Stdout { .. } => Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
span,
|
||||
"stdout does not support resource.read",
|
||||
)),
|
||||
Stream::FileWriter { .. } => Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
span,
|
||||
"a file write stream does not support resource.read",
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Validate a stdout write and return the accepted byte count.
|
||||
///
|
||||
/// The caller performs the output-budget accounting and buffer append; this
|
||||
/// method only checks handle identity, closed state and stream kind.
|
||||
pub fn write(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
bytes: &[u8],
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
let slot = self.slot_mut(handle, span)?;
|
||||
if slot.closed() {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceClosed,
|
||||
span,
|
||||
"Resource handle is closed",
|
||||
));
|
||||
}
|
||||
match &mut slot.stream {
|
||||
Stream::Stdout { .. } => Ok(bytes.len()),
|
||||
Stream::File { relative, .. } => Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceUnsupported,
|
||||
span,
|
||||
format!("project file `{relative}` was opened read-only"),
|
||||
)),
|
||||
Stream::FileWriter {
|
||||
relative,
|
||||
bytes: buffer,
|
||||
..
|
||||
} => {
|
||||
let next = buffer.len().checked_add(bytes.len());
|
||||
let Some(next) = next else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!("file write buffer for `{relative}` overflows"),
|
||||
));
|
||||
};
|
||||
if next > crate::fs::MAX_READ_BYTES as usize {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"file write buffer for `{relative}` exceeds the {} byte limit",
|
||||
crate::fs::MAX_READ_BYTES
|
||||
),
|
||||
));
|
||||
}
|
||||
buffer.extend_from_slice(bytes);
|
||||
Ok(bytes.len())
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// Close a stream. A second close is `resource.closed`.
|
||||
pub fn close(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let slot = self.slot_mut(handle, span)?;
|
||||
if slot.closed() {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceClosed,
|
||||
span,
|
||||
"Resource handle is already closed",
|
||||
));
|
||||
}
|
||||
match &mut slot.stream {
|
||||
Stream::Stdout { closed } => *closed = true,
|
||||
Stream::File { closed, .. } => *closed = true,
|
||||
Stream::FileWriter { closed, .. } => *closed = true,
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Return the buffered bytes of a file write stream without closing it.
|
||||
///
|
||||
/// `None` means the handle is not a file writer (stdout or a reader). The
|
||||
/// caller must call [`Self::close`] only after the flush succeeds, so a
|
||||
/// failed flush leaves the writer open with its buffer intact.
|
||||
pub fn pending_file_write(
|
||||
&self,
|
||||
handle: ResourceHandle,
|
||||
span: Option<Span>,
|
||||
) -> Result<Option<(String, Vec<u8>)>, RuntimeError> {
|
||||
let slot = self.slot(handle, span)?;
|
||||
if slot.closed() {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceClosed,
|
||||
span,
|
||||
"Resource handle is closed",
|
||||
));
|
||||
}
|
||||
match &slot.stream {
|
||||
Stream::FileWriter {
|
||||
relative, bytes, ..
|
||||
} => Ok(Some((relative.clone(), bytes.clone()))),
|
||||
_ => Ok(None),
|
||||
}
|
||||
}
|
||||
|
||||
/// Descriptor kind for diagnostics/trace, if the handle is valid.
|
||||
pub fn kind(
|
||||
&self,
|
||||
handle: ResourceHandle,
|
||||
span: Option<Span>,
|
||||
) -> Result<&'static str, RuntimeError> {
|
||||
let slot = self.slot(handle, span)?;
|
||||
Ok(match slot.stream {
|
||||
Stream::Stdout { .. } => "stdio",
|
||||
Stream::File { .. } | Stream::FileWriter { .. } => "file",
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
fn unknown_handle(span: Option<Span>) -> RuntimeError {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::ResourceFault,
|
||||
span,
|
||||
"unknown Resource handle",
|
||||
)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn file_reads_are_chunked_with_eof() {
|
||||
let mut table = ResourceTable::new();
|
||||
let handle = table.open_file("data.txt", b"abcdef".to_vec());
|
||||
assert_eq!(
|
||||
table.read(handle, 2, None).unwrap(),
|
||||
ResourceRead {
|
||||
bytes: b"ab".to_vec(),
|
||||
eof: false
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
table.read(handle, 8, None).unwrap(),
|
||||
ResourceRead {
|
||||
bytes: b"cdef".to_vec(),
|
||||
eof: true
|
||||
}
|
||||
);
|
||||
assert_eq!(
|
||||
table.read(handle, 1, None).unwrap(),
|
||||
ResourceRead {
|
||||
bytes: Vec::new(),
|
||||
eof: true
|
||||
}
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn forged_and_closed_handles_are_rejected() {
|
||||
let mut table = ResourceTable::new();
|
||||
let handle = table.open_stdout();
|
||||
let forged = ResourceHandle::from_host(handle.run_id() + 1, handle.resource_id(), 1);
|
||||
assert_eq!(
|
||||
table.write(forged, b"x", None).unwrap_err().code(),
|
||||
"runtime.resource"
|
||||
);
|
||||
table.close(handle, None).unwrap();
|
||||
assert_eq!(
|
||||
table.write(handle, b"x", None).unwrap_err().code(),
|
||||
"resource.closed"
|
||||
);
|
||||
assert_eq!(
|
||||
table.close(handle, None).unwrap_err().code(),
|
||||
"resource.closed"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stdout_is_not_readable_and_file_is_not_writable() {
|
||||
let mut table = ResourceTable::new();
|
||||
let stdout = table.open_stdout();
|
||||
assert_eq!(
|
||||
table.read(stdout, 1, None).unwrap_err().code(),
|
||||
"resource.unsupported"
|
||||
);
|
||||
let file = table.open_file("x.txt", Vec::new());
|
||||
assert_eq!(
|
||||
table.write(file, b"x", None).unwrap_err().code(),
|
||||
"resource.unsupported"
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,205 @@
|
||||
//! Resource/stream host boundary tests (ADR-0025).
|
||||
|
||||
use std::path::Path;
|
||||
|
||||
use marqdo_host::{Capabilities, ExecutionContext, Host, HostOp, StdHost};
|
||||
use marqdo_sandbox::SandboxMode;
|
||||
use marqdo_value::{ErrorCategory, Value};
|
||||
|
||||
fn context() -> ExecutionContext {
|
||||
ExecutionContext::new("index.mq.md".to_string(), None)
|
||||
}
|
||||
|
||||
fn handle(value: Value) -> marqdo_value::ResourceHandle {
|
||||
match value {
|
||||
Value::Resource(handle) => handle,
|
||||
other => panic!("expected a Resource handle, got {other:?}"),
|
||||
}
|
||||
}
|
||||
|
||||
fn write_project_file(root: &Path, name: &str, contents: &[u8]) {
|
||||
std::fs::write(root.join(name), contents).unwrap();
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pure_mode_writes_stdout_through_a_resource() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut host = StdHost::new(SandboxMode::Pure, Capabilities::pure(), dir.path());
|
||||
let ctx = context();
|
||||
let handle = handle(
|
||||
host.resource_open("stdio", "stdout", &["write".to_string()], &ctx)
|
||||
.unwrap(),
|
||||
);
|
||||
assert_eq!(host.resource_write(handle, b"hello", &ctx).unwrap(), 5);
|
||||
assert_eq!(host.take_output(), b"hello");
|
||||
host.resource_close(handle, &ctx).unwrap();
|
||||
let error = host.resource_close(handle, &ctx).unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::ResourceClosed);
|
||||
assert_eq!(error.code(), "resource.closed");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn stdout_write_obeys_the_output_budget_atomically() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut host = StdHost::new(SandboxMode::Pure, Capabilities::pure(), dir.path());
|
||||
host.budget.max_output_bytes = 3;
|
||||
let ctx = context();
|
||||
let handle = handle(
|
||||
host.resource_open("stdio", "stdout", &["write".to_string()], &ctx)
|
||||
.unwrap(),
|
||||
);
|
||||
let error = host.resource_write(handle, b"hello", &ctx).unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::ResourceExhausted);
|
||||
assert!(host.take_output().is_empty());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn strict_mode_refuses_every_resource_open() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut host = StdHost::new(SandboxMode::Strict, Capabilities::pure(), dir.path());
|
||||
let error = host
|
||||
.resource_open("stdio", "stdout", &["write".to_string()], &context())
|
||||
.unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::PermissionDenied);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resource_handles_cannot_cross_the_generic_host_boundary() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut host = StdHost::new(SandboxMode::Pure, Capabilities::pure(), dir.path());
|
||||
let ctx = context();
|
||||
let handle = handle(
|
||||
host.resource_open("stdio", "stdout", &["write".to_string()], &ctx)
|
||||
.unwrap(),
|
||||
);
|
||||
let error = host
|
||||
.invoke(HostOp::Print, vec![Value::Resource(handle)], &ctx)
|
||||
.unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::Type);
|
||||
assert!(error.message.contains("Resource handles"));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn pure_mode_refuses_file_resources_even_with_a_grant() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
write_project_file(dir.path(), "a.txt", b"abcdef");
|
||||
let mut host = StdHost::new(
|
||||
SandboxMode::Pure,
|
||||
Capabilities::pure().allow_read("a.txt"),
|
||||
dir.path(),
|
||||
);
|
||||
let error = host
|
||||
.resource_open("file", "a.txt", &["read".to_string()], &context())
|
||||
.unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::PermissionDenied);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn project_file_writes_buffer_until_close_and_require_a_grant() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut host = StdHost::new(
|
||||
SandboxMode::Project,
|
||||
Capabilities::project().allow_write("out.bin"),
|
||||
dir.path(),
|
||||
);
|
||||
let ctx = context();
|
||||
let handle = handle(
|
||||
host.resource_open("file", "out.bin", &["write".to_string()], &ctx)
|
||||
.unwrap(),
|
||||
);
|
||||
assert_eq!(host.resource_write(handle, b"abc", &ctx).unwrap(), 3);
|
||||
assert_eq!(host.resource_write(handle, b"def", &ctx).unwrap(), 3);
|
||||
assert!(
|
||||
!dir.path().join("out.bin").exists(),
|
||||
"write must not flush early"
|
||||
);
|
||||
host.resource_close(handle, &ctx).unwrap();
|
||||
assert_eq!(
|
||||
std::fs::read(dir.path().join("out.bin")).unwrap(),
|
||||
b"abcdef"
|
||||
);
|
||||
|
||||
let error = host.resource_read(handle, 1, &ctx).unwrap_err();
|
||||
assert_eq!(error.code(), "resource.closed");
|
||||
let second = host.resource_close(handle, &ctx).unwrap_err();
|
||||
assert_eq!(second.code(), "resource.closed");
|
||||
|
||||
let mut denied = StdHost::new(SandboxMode::Project, Capabilities::project(), dir.path());
|
||||
let error = denied
|
||||
.resource_open("file", "out.bin", &["write".to_string()], &ctx)
|
||||
.unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::PermissionDenied);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn file_write_buffer_has_a_hard_ceiling() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut host = StdHost::new(
|
||||
SandboxMode::Project,
|
||||
Capabilities::project().allow_write("big.bin"),
|
||||
dir.path(),
|
||||
);
|
||||
let ctx = context();
|
||||
let handle = handle(
|
||||
host.resource_open("file", "big.bin", &["write".to_string()], &ctx)
|
||||
.unwrap(),
|
||||
);
|
||||
let oversized = vec![0u8; marqdo_host::fs::MAX_READ_BYTES as usize + 1];
|
||||
let error = host.resource_write(handle, &oversized, &ctx).unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::ResourceExhausted);
|
||||
assert_eq!(host.resource_write(handle, b"ok", &ctx).unwrap(), 2);
|
||||
host.resource_close(handle, &ctx).unwrap();
|
||||
assert_eq!(std::fs::read(dir.path().join("big.bin")).unwrap(), b"ok");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn project_file_reads_are_chunked_and_require_a_grant() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
write_project_file(dir.path(), "a.txt", b"abcdef");
|
||||
let mut host = StdHost::new(
|
||||
SandboxMode::Project,
|
||||
Capabilities::project().allow_read("a.txt"),
|
||||
dir.path(),
|
||||
);
|
||||
let ctx = context();
|
||||
let handle = handle(
|
||||
host.resource_open("file", "a.txt", &["read".to_string()], &ctx)
|
||||
.unwrap(),
|
||||
);
|
||||
let first = host.resource_read(handle, 2, &ctx).unwrap();
|
||||
assert_eq!(first.bytes, b"ab");
|
||||
assert!(!first.eof);
|
||||
let second = host.resource_read(handle, 8, &ctx).unwrap();
|
||||
assert_eq!(second.bytes, b"cdef");
|
||||
assert!(second.eof);
|
||||
assert!(host.resource_read(handle, 1, &ctx).unwrap().eof);
|
||||
|
||||
let mut denied = StdHost::new(SandboxMode::Project, Capabilities::project(), dir.path());
|
||||
let error = denied
|
||||
.resource_open("file", "a.txt", &["read".to_string()], &ctx)
|
||||
.unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::PermissionDenied);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn traversal_and_unsupported_rights_are_refused() {
|
||||
let dir = tempfile::tempdir().unwrap();
|
||||
let mut host = StdHost::new(
|
||||
SandboxMode::Project,
|
||||
Capabilities::project().allow_read("**"),
|
||||
dir.path(),
|
||||
);
|
||||
let ctx = context();
|
||||
let traversal = host
|
||||
.resource_open("file", "../secret", &["read".to_string()], &ctx)
|
||||
.unwrap_err();
|
||||
assert_eq!(traversal.category, ErrorCategory::PermissionDenied);
|
||||
let write_rights = host
|
||||
.resource_open("stdio", "stdout", &["read".to_string()], &ctx)
|
||||
.unwrap_err();
|
||||
assert_eq!(write_rights.category, ErrorCategory::ResourceUnsupported);
|
||||
let unknown_kind = host
|
||||
.resource_open("socket", "example.test", &["read".to_string()], &ctx)
|
||||
.unwrap_err();
|
||||
assert_eq!(unknown_kind.category, ErrorCategory::ResourceUnsupported);
|
||||
}
|
||||
@@ -167,6 +167,144 @@ const FS_WRITE: Builtin = Builtin {
|
||||
named_only: false,
|
||||
effectful: true,
|
||||
};
|
||||
const MEMORY_NEW: Builtin = Builtin {
|
||||
name: "memory.new",
|
||||
aliases: &[],
|
||||
params: &[req("initial_pages"), req("max_pages")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const MEMORY_SIZE: Builtin = Builtin {
|
||||
name: "memory.size",
|
||||
aliases: &[],
|
||||
params: &[req("memory")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const MEMORY_GROW: Builtin = Builtin {
|
||||
name: "memory.grow",
|
||||
aliases: &[],
|
||||
params: &[req("memory"), req("pages")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const LIST_APPEND: Builtin = Builtin {
|
||||
name: "list.append",
|
||||
aliases: &[],
|
||||
params: &[req("list"), req("value")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const LIST_CONCAT: Builtin = Builtin {
|
||||
name: "list.concat",
|
||||
aliases: &[],
|
||||
params: &[req("left"), req("right")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const MAP_KEYS: Builtin = Builtin {
|
||||
name: "map.keys",
|
||||
aliases: &[],
|
||||
params: &[req("map")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const MAP_HAS: Builtin = Builtin {
|
||||
name: "map.has",
|
||||
aliases: &[],
|
||||
params: &[req("map"), req("key")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const MAP_GET: Builtin = Builtin {
|
||||
name: "map.get",
|
||||
aliases: &[],
|
||||
params: &[req("map"), req("key")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const MAP_SET: Builtin = Builtin {
|
||||
name: "map.set",
|
||||
aliases: &[],
|
||||
params: &[req("map"), req("key"), req("value")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const MAP_REMOVE: Builtin = Builtin {
|
||||
name: "map.remove",
|
||||
aliases: &[],
|
||||
params: &[req("map"), req("key")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const TEXT_CODEPOINTS: Builtin = Builtin {
|
||||
name: "text.codepoints",
|
||||
aliases: &[],
|
||||
params: &[req("text")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const TEXT_FROM_CODEPOINT: Builtin = Builtin {
|
||||
name: "text.from_codepoint",
|
||||
aliases: &[],
|
||||
params: &[req("codepoint")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const TABLE_COLUMNS: Builtin = Builtin {
|
||||
name: "table.columns",
|
||||
aliases: &[],
|
||||
params: &[req("table")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const TABLE_ROW: Builtin = Builtin {
|
||||
name: "table.row",
|
||||
aliases: &[],
|
||||
params: &[req("table"), req("row")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
const RESOURCE_OPEN: Builtin = Builtin {
|
||||
name: "resource.open",
|
||||
aliases: &[],
|
||||
params: &[req("kind"), req("descriptor"), req("rights")],
|
||||
named_only: false,
|
||||
effectful: true,
|
||||
};
|
||||
const RESOURCE_READ: Builtin = Builtin {
|
||||
name: "resource.read",
|
||||
aliases: &[],
|
||||
params: &[
|
||||
req("handle"),
|
||||
req("memory"),
|
||||
req("offset"),
|
||||
req("max_bytes"),
|
||||
],
|
||||
named_only: false,
|
||||
effectful: true,
|
||||
};
|
||||
const RESOURCE_WRITE: Builtin = Builtin {
|
||||
name: "resource.write",
|
||||
aliases: &[],
|
||||
params: &[req("handle"), req("memory"), req("offset"), req("length")],
|
||||
named_only: false,
|
||||
effectful: true,
|
||||
};
|
||||
const RESOURCE_CLOSE: Builtin = Builtin {
|
||||
name: "resource.close",
|
||||
aliases: &[],
|
||||
params: &[req("handle")],
|
||||
named_only: false,
|
||||
effectful: true,
|
||||
};
|
||||
const TABLE_CELL: Builtin = Builtin {
|
||||
name: "table.cell",
|
||||
aliases: &[],
|
||||
params: &[req("table"), req("row"), req("column")],
|
||||
named_only: false,
|
||||
effectful: false,
|
||||
};
|
||||
|
||||
/// All builtins known to the language. Host availability is decided at call
|
||||
/// time by the capability layer, not here.
|
||||
@@ -188,6 +326,25 @@ pub const BUILTINS: &[Builtin] = &[
|
||||
FOREIGN_CALL,
|
||||
FS_READ,
|
||||
FS_WRITE,
|
||||
MEMORY_NEW,
|
||||
MEMORY_SIZE,
|
||||
MEMORY_GROW,
|
||||
LIST_APPEND,
|
||||
LIST_CONCAT,
|
||||
MAP_KEYS,
|
||||
MAP_HAS,
|
||||
MAP_GET,
|
||||
MAP_SET,
|
||||
MAP_REMOVE,
|
||||
TEXT_CODEPOINTS,
|
||||
TEXT_FROM_CODEPOINT,
|
||||
TABLE_COLUMNS,
|
||||
TABLE_ROW,
|
||||
TABLE_CELL,
|
||||
RESOURCE_OPEN,
|
||||
RESOURCE_READ,
|
||||
RESOURCE_WRITE,
|
||||
RESOURCE_CLOSE,
|
||||
];
|
||||
|
||||
/// Find a builtin by canonical name or alias.
|
||||
|
||||
@@ -224,16 +224,51 @@ pub struct Function {
|
||||
pub body: Vec<Stmt>,
|
||||
}
|
||||
|
||||
/// Writable place of an assignment (ADR-0022).
|
||||
///
|
||||
/// The Markdown surface is unchanged: both variants are `strong` nodes whose
|
||||
/// payload contains `target = expression`. `Local` rebinds a frame slot;
|
||||
/// `Index` writes one byte into an addressable runtime `Memory` region and is
|
||||
/// rejected for every other base value.
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(tag = "place", rename_all = "snake_case")]
|
||||
pub enum PlaceTarget {
|
||||
/// Local slot rebinding.
|
||||
Local {
|
||||
/// Target name.
|
||||
name: String,
|
||||
/// Span of the target name.
|
||||
name_span: Span,
|
||||
},
|
||||
/// `base[index] = value`; only a `Memory` base is writable.
|
||||
Index {
|
||||
/// Base expression, evaluated first.
|
||||
base: Expr,
|
||||
/// Index expression, evaluated second.
|
||||
index: Expr,
|
||||
/// Span from the base start through the closing `]`.
|
||||
span: Span,
|
||||
},
|
||||
}
|
||||
|
||||
impl PlaceTarget {
|
||||
/// Best known source span of the place.
|
||||
pub fn span(&self) -> Span {
|
||||
match self {
|
||||
PlaceTarget::Local { name_span, .. } => *name_span,
|
||||
PlaceTarget::Index { span, .. } => *span,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/// An executable statement.
|
||||
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
||||
#[serde(tag = "stmt", rename_all = "snake_case")]
|
||||
pub enum Stmt {
|
||||
/// Local assignment (`strong` node with `name = expr`).
|
||||
/// Assignment to a local slot or a `Memory` index.
|
||||
Assign {
|
||||
/// Target name.
|
||||
name: String,
|
||||
/// Span of the target name (approximated by the payload span).
|
||||
name_span: Span,
|
||||
/// Writable place.
|
||||
target: PlaceTarget,
|
||||
/// Value expression.
|
||||
value: Expr,
|
||||
/// Span of the whole statement.
|
||||
|
||||
@@ -6,13 +6,13 @@
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use marqdo_host::HostOp;
|
||||
use marqdo_host::{HostOp, ResourceRead};
|
||||
use marqdo_ir::builtins::Builtin;
|
||||
use marqdo_ir::Resource;
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{
|
||||
float_to_bigint, CodeValue, ErrorCategory, FormulaValue, FunctionRef, RuntimeError, Table,
|
||||
Value,
|
||||
float_to_bigint, CodeValue, ErrorCategory, FormulaValue, FunctionRef, ResourceHandle,
|
||||
RuntimeError, Table, Value,
|
||||
};
|
||||
|
||||
use crate::interpreter::Interpreter;
|
||||
@@ -187,6 +187,292 @@ pub(crate) fn dispatch(
|
||||
&module,
|
||||
)
|
||||
}
|
||||
"memory.new" => {
|
||||
let initial_pages = page_count(take(&bound, "initial_pages", builtin, span)?, span)?;
|
||||
let max_pages = page_count(take(&bound, "max_pages", builtin, span)?, span)?;
|
||||
let handle = interpreter
|
||||
.memory_mut()
|
||||
.create(initial_pages, max_pages, span)?;
|
||||
interpreter.record_memory_event(
|
||||
"memory.new",
|
||||
&module,
|
||||
span,
|
||||
&format!("initial_pages={initial_pages} max_pages={max_pages}"),
|
||||
);
|
||||
Ok(Value::Memory(handle))
|
||||
}
|
||||
"memory.size" => {
|
||||
let memory = take(&bound, "memory", builtin, span)?;
|
||||
let memory_type = memory.type_name();
|
||||
let Value::Memory(handle) = memory else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("memory.size expects a Memory value, got {memory_type}"),
|
||||
));
|
||||
};
|
||||
let pages = interpreter.memory().size(handle, span)?;
|
||||
Ok(pages_value(pages, span)?)
|
||||
}
|
||||
"memory.grow" => {
|
||||
let memory = take(&bound, "memory", builtin, span)?;
|
||||
let memory_type = memory.type_name();
|
||||
let Value::Memory(handle) = memory else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("memory.grow expects a Memory value, got {memory_type}"),
|
||||
));
|
||||
};
|
||||
let pages = page_count(take(&bound, "pages", builtin, span)?, span)?;
|
||||
let old_pages = interpreter.memory_mut().grow(handle, pages, span)?;
|
||||
interpreter.record_memory_event(
|
||||
"memory.grow",
|
||||
&module,
|
||||
span,
|
||||
&format!("pages={pages} old_pages={old_pages}"),
|
||||
);
|
||||
Ok(pages_value(old_pages, span)?)
|
||||
}
|
||||
"list.append" => {
|
||||
let list = take(&bound, "list", builtin, span)?;
|
||||
let value = take(&bound, "value", builtin, span)?;
|
||||
let list_type = list.type_name();
|
||||
let Value::List(mut items) = list else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("list.append expects a List, got {list_type}"),
|
||||
));
|
||||
};
|
||||
items.push(value);
|
||||
Ok(Value::List(items))
|
||||
}
|
||||
"list.concat" => {
|
||||
let left = take(&bound, "left", builtin, span)?;
|
||||
let right = take(&bound, "right", builtin, span)?;
|
||||
let left_type = left.type_name();
|
||||
let Value::List(mut items) = left else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("list.concat left operand must be a List, got {left_type}"),
|
||||
));
|
||||
};
|
||||
let right_type = right.type_name();
|
||||
let Value::List(other) = right else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("list.concat right operand must be a List, got {right_type}"),
|
||||
));
|
||||
};
|
||||
items.extend(other);
|
||||
Ok(Value::List(items))
|
||||
}
|
||||
"map.keys" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.keys expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(Value::List(
|
||||
map.keys().cloned().map(Value::Text).collect::<Vec<_>>(),
|
||||
))
|
||||
}
|
||||
"map.has" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let key = map_key(take(&bound, "key", builtin, span)?, "map.has", span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.has expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(Value::Bool(map.contains_key(&key)))
|
||||
}
|
||||
"map.get" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let key = map_key(take(&bound, "key", builtin, span)?, "map.get", span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.get expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(map.get(&key).cloned().unwrap_or(Value::None))
|
||||
}
|
||||
"map.set" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let key = map_key(take(&bound, "key", builtin, span)?, "map.set", span)?;
|
||||
let new_value = take(&bound, "value", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(mut map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.set expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
map.insert(key, new_value);
|
||||
Ok(Value::Map(map))
|
||||
}
|
||||
"map.remove" => {
|
||||
let value = take(&bound, "map", builtin, span)?;
|
||||
let key = map_key(take(&bound, "key", builtin, span)?, "map.remove", span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Map(mut map) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("map.remove expects a Map, got {value_type}"),
|
||||
));
|
||||
};
|
||||
map.remove(&key);
|
||||
Ok(Value::Map(map))
|
||||
}
|
||||
"text.codepoints" => {
|
||||
let value = take(&bound, "text", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Text(text) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("text.codepoints expects Text, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(Value::List(
|
||||
text.chars()
|
||||
.map(|character| Value::int(i64::from(character as u32)))
|
||||
.collect(),
|
||||
))
|
||||
}
|
||||
"text.from_codepoint" => {
|
||||
let value = take(&bound, "codepoint", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(codepoint) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("text.from_codepoint expects an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let Some(codepoint) = num_traits::ToPrimitive::to_u32(&codepoint) else {
|
||||
return Ok(Value::None);
|
||||
};
|
||||
Ok(match char::from_u32(codepoint) {
|
||||
Some(character) => Value::Text(character.to_string()),
|
||||
None => Value::None,
|
||||
})
|
||||
}
|
||||
"table.columns" => {
|
||||
let value = take(&bound, "table", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Table(table) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("table.columns expects a Table, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(Value::List(
|
||||
table.header.into_iter().map(Value::Text).collect(),
|
||||
))
|
||||
}
|
||||
"table.row" => {
|
||||
let value = take(&bound, "table", builtin, span)?;
|
||||
let row = take(&bound, "row", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Table(table) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("table.row expects a Table, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let position = table_index(row, table.rows.len(), "row", span)?;
|
||||
Ok(Value::List(table.rows[position].clone()))
|
||||
}
|
||||
"table.cell" => {
|
||||
let value = take(&bound, "table", builtin, span)?;
|
||||
let row = take(&bound, "row", builtin, span)?;
|
||||
let column = take(&bound, "column", builtin, span)?;
|
||||
let value_type = value.type_name();
|
||||
let Value::Table(table) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("table.cell expects a Table, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let row = table_index(row, table.rows.len(), "row", span)?;
|
||||
let column = table_index(column, table.header.len(), "column", span)?;
|
||||
Ok(table.rows[row][column].clone())
|
||||
}
|
||||
"resource.open" => {
|
||||
let kind = expect_text_value(take(&bound, "kind", builtin, span)?, span)?;
|
||||
let descriptor = expect_text_value(take(&bound, "descriptor", builtin, span)?, span)?;
|
||||
let rights = rights_list(take(&bound, "rights", builtin, span)?, span)?;
|
||||
interpreter.resource_open(&kind, &descriptor, &rights, &module, span)
|
||||
}
|
||||
"resource.read" => {
|
||||
let handle = resource_handle(take(&bound, "handle", builtin, span)?, span)?;
|
||||
let memory = memory_handle(
|
||||
take(&bound, "memory", builtin, span)?,
|
||||
"resource.read",
|
||||
span,
|
||||
)?;
|
||||
let offset = take(&bound, "offset", builtin, span)?;
|
||||
let offset_int = int_value(offset, "resource.read offset", span)?;
|
||||
let offset_value = Value::Int(offset_int.clone());
|
||||
let max_bytes = positive_count(
|
||||
take(&bound, "max_bytes", builtin, span)?,
|
||||
"resource.read max_bytes",
|
||||
span,
|
||||
)?;
|
||||
let available = interpreter.memory().byte_len(memory, span)?;
|
||||
let start = non_negative_usize(&offset_value, "resource.read offset", span)?;
|
||||
if start >= available {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("resource.read offset {start} is at or beyond the Memory length {available}"),
|
||||
));
|
||||
}
|
||||
let limit = max_bytes.min(available - start);
|
||||
let result = interpreter.resource_read(handle, limit, &module, span);
|
||||
match result {
|
||||
Ok(read) => {
|
||||
interpreter
|
||||
.memory_mut()
|
||||
.write_bytes(memory, &offset_int, &read.bytes, span)?;
|
||||
Ok(resource_ok(resource_read_payload(&read)))
|
||||
}
|
||||
Err(error) => resource_recoverable(error),
|
||||
}
|
||||
}
|
||||
"resource.write" => {
|
||||
let handle = resource_handle(take(&bound, "handle", builtin, span)?, span)?;
|
||||
let memory = memory_handle(
|
||||
take(&bound, "memory", builtin, span)?,
|
||||
"resource.write",
|
||||
span,
|
||||
)?;
|
||||
let offset = take(&bound, "offset", builtin, span)?;
|
||||
let offset_int = int_value(offset, "resource.write offset", span)?;
|
||||
let length = non_negative_usize(
|
||||
&take(&bound, "length", builtin, span)?,
|
||||
"resource.write length",
|
||||
span,
|
||||
)?;
|
||||
let bytes = interpreter
|
||||
.memory()
|
||||
.read_bytes(memory, &offset_int, length, span)?;
|
||||
match interpreter.resource_write(handle, &bytes, &module, span) {
|
||||
Ok(count) => Ok(resource_ok(resource_write_payload(count))),
|
||||
Err(error) => resource_recoverable(error),
|
||||
}
|
||||
}
|
||||
"resource.close" => {
|
||||
let handle = resource_handle(take(&bound, "handle", builtin, span)?, span)?;
|
||||
match interpreter.resource_close(handle, &module, span) {
|
||||
Ok(()) => Ok(resource_ok(Value::None)),
|
||||
Err(error) => resource_recoverable(error),
|
||||
}
|
||||
}
|
||||
other => Err(RuntimeError::new(
|
||||
ErrorCategory::KernelUnavailable,
|
||||
span,
|
||||
@@ -210,6 +496,228 @@ fn take(
|
||||
})
|
||||
}
|
||||
|
||||
/// Validate a page-count argument: an `Int` in the non-negative `u64` range.
|
||||
fn page_count(value: Value, span: Option<Span>) -> Result<u64, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(count) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("memory page count must be an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
num_traits::ToPrimitive::to_u64(&count).ok_or_else(|| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::MemoryFault,
|
||||
span,
|
||||
format!("memory page count {count} must be a non-negative integer"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Convert a page count back to a language `Int`.
|
||||
fn pages_value(pages: u64, span: Option<Span>) -> Result<Value, RuntimeError> {
|
||||
i64::try_from(pages).map(Value::int).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::MemoryFault,
|
||||
span,
|
||||
format!("page count {pages} does not fit an Int"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Require a `Text` map key and return it.
|
||||
fn map_key(value: Value, builtin: &str, span: Option<Span>) -> Result<String, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
match value {
|
||||
Value::Text(key) => Ok(key),
|
||||
_ => Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{builtin} key must be Text, got {value_type}"),
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
/// Require a Text value.
|
||||
fn expect_text_value(value: Value, span: Option<Span>) -> Result<String, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Text(text) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("expected Text, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(text)
|
||||
}
|
||||
|
||||
/// Require a List of Text rights.
|
||||
fn rights_list(value: Value, span: Option<Span>) -> Result<Vec<String>, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::List(items) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("resource rights must be a List, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let mut rights = Vec::with_capacity(items.len());
|
||||
for item in items {
|
||||
let item_type = item.type_name();
|
||||
let Value::Text(right) = item else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("resource rights must contain Text, got {item_type}"),
|
||||
));
|
||||
};
|
||||
rights.push(right);
|
||||
}
|
||||
Ok(rights)
|
||||
}
|
||||
|
||||
/// Require an opaque resource handle.
|
||||
fn resource_handle(value: Value, span: Option<Span>) -> Result<ResourceHandle, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Resource(handle) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("expected a Resource handle, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(handle)
|
||||
}
|
||||
|
||||
/// Require an opaque Memory handle.
|
||||
fn memory_handle(
|
||||
value: Value,
|
||||
builtin: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<marqdo_value::MemoryHandle, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Memory(handle) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{builtin} memory must be a Memory value, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(handle)
|
||||
}
|
||||
|
||||
/// Require an Int value.
|
||||
fn int_value(
|
||||
value: Value,
|
||||
what: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<num_bigint::BigInt, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(value) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{what} must be an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
Ok(value)
|
||||
}
|
||||
|
||||
/// Require a non-negative usize.
|
||||
fn non_negative_usize(
|
||||
value: &Value,
|
||||
what: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(value) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{what} must be an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
num_traits::ToPrimitive::to_usize(value).ok_or_else(|| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("{what} {value} must be a non-negative integer in range"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Require a strictly positive byte count.
|
||||
fn positive_count(value: Value, what: &str, span: Option<Span>) -> Result<usize, RuntimeError> {
|
||||
let count = non_negative_usize(&value, what, span)?;
|
||||
if count == 0 {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("{what} must be greater than zero"),
|
||||
));
|
||||
}
|
||||
Ok(count)
|
||||
}
|
||||
|
||||
fn resource_ok(value: Value) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("ok".to_string(), Value::Bool(true));
|
||||
map.insert("value".to_string(), value);
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
fn resource_err(code: &str, message: &str) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("ok".to_string(), Value::Bool(false));
|
||||
map.insert("code".to_string(), Value::Text(code.to_string()));
|
||||
map.insert("message".to_string(), Value::Text(message.to_string()));
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
fn resource_read_payload(read: &ResourceRead) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("count".to_string(), Value::int(read.bytes.len() as i64));
|
||||
map.insert("eof".to_string(), Value::Bool(read.eof));
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
fn resource_write_payload(count: usize) -> Value {
|
||||
let mut map = BTreeMap::new();
|
||||
map.insert("count".to_string(), Value::int(count as i64));
|
||||
Value::Map(map)
|
||||
}
|
||||
|
||||
/// Convert a closed-handle failure into a recoverable Result; other errors are
|
||||
/// fatal (ADR-0025).
|
||||
fn resource_recoverable(error: RuntimeError) -> Result<Value, RuntimeError> {
|
||||
if error.category == ErrorCategory::ResourceClosed {
|
||||
return Ok(resource_err("resource.closed", &error.message));
|
||||
}
|
||||
Err(error)
|
||||
}
|
||||
|
||||
/// Validate a non-negative table row/column coordinate.
|
||||
fn table_index(
|
||||
value: Value,
|
||||
len: usize,
|
||||
what: &str,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
let value_type = value.type_name();
|
||||
let Value::Int(index) = value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("table {what} must be an Int, got {value_type}"),
|
||||
));
|
||||
};
|
||||
let Some(position) = num_traits::ToPrimitive::to_usize(&index) else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("table {what} {index} is out of bounds for length {len}"),
|
||||
));
|
||||
};
|
||||
if position >= len {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("table {what} {position} is out of bounds for length {len}"),
|
||||
));
|
||||
}
|
||||
Ok(position)
|
||||
}
|
||||
|
||||
fn formula_text(value: Value, span: Option<Span>) -> Result<String, RuntimeError> {
|
||||
match value {
|
||||
Value::Formula(formula) => Ok(formula.latex),
|
||||
|
||||
@@ -3,12 +3,13 @@
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use marqdo_expression::{BinaryOp, Expr, RecordEntry};
|
||||
use marqdo_host::{ExecutionContext, Host, HostOp};
|
||||
use marqdo_ir::{builtins, CallTarget, Function, FunctionId, ModuleId, Program, Stmt};
|
||||
use marqdo_host::{ExecutionContext, Host, HostOp, ResourceRead};
|
||||
use marqdo_ir::{builtins, CallTarget, Function, FunctionId, ModuleId, PlaceTarget, Program, Stmt};
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{ErrorCategory, RuntimeError, Value};
|
||||
use marqdo_value::{ErrorCategory, ResourceHandle, RuntimeError, Value};
|
||||
|
||||
use crate::builtins_impl::FrameView;
|
||||
use crate::memory::{MemoryLimits, MemoryStore};
|
||||
|
||||
use crate::value_ops;
|
||||
|
||||
@@ -68,6 +69,7 @@ pub struct Interpreter<'a> {
|
||||
program: &'a Program,
|
||||
host: &'a mut dyn Host,
|
||||
depth: usize,
|
||||
memory: MemoryStore,
|
||||
}
|
||||
|
||||
/// Run a named function with already-evaluated arguments.
|
||||
@@ -77,11 +79,31 @@ pub fn run(
|
||||
module: &ModuleId,
|
||||
function: &str,
|
||||
args: Vec<EvaluatedArg>,
|
||||
) -> Result<RunOutcome, RuntimeError> {
|
||||
run_with_limits(
|
||||
program,
|
||||
host,
|
||||
module,
|
||||
function,
|
||||
args,
|
||||
MemoryLimits::default(),
|
||||
)
|
||||
}
|
||||
|
||||
/// Run with explicit addressable-memory limits (ADR-0022).
|
||||
pub fn run_with_limits(
|
||||
program: &Program,
|
||||
host: &mut dyn Host,
|
||||
module: &ModuleId,
|
||||
function: &str,
|
||||
args: Vec<EvaluatedArg>,
|
||||
limits: MemoryLimits,
|
||||
) -> Result<RunOutcome, RuntimeError> {
|
||||
let mut interpreter = Interpreter {
|
||||
program,
|
||||
host,
|
||||
depth: 0,
|
||||
memory: MemoryStore::new(limits),
|
||||
};
|
||||
let value = interpreter.call_by_name(module, function, args, None)?;
|
||||
Ok(RunOutcome { value })
|
||||
@@ -300,10 +322,25 @@ impl<'a> Interpreter<'a> {
|
||||
self.host.consume_fuel(1, Some(stmt.span()))?;
|
||||
self.host.check_deadline(Some(stmt.span()))?;
|
||||
match stmt {
|
||||
Stmt::Assign { name, value, .. } => {
|
||||
let value = self.eval_expr(value, frame)?;
|
||||
frame.locals.insert(name.clone(), value);
|
||||
}
|
||||
Stmt::Assign { target, value, .. } => match target {
|
||||
PlaceTarget::Local { name, .. } => {
|
||||
let value = self.eval_expr(value, frame)?;
|
||||
frame.locals.insert(name.clone(), value);
|
||||
}
|
||||
PlaceTarget::Index { base, index, span } => {
|
||||
// Frozen order (ADR-0022): base, index, then RHS.
|
||||
let base_value = self.eval_expr(base, frame)?;
|
||||
let index_value = self.eval_expr(index, frame)?;
|
||||
let byte_value = self.eval_expr(value, frame)?;
|
||||
self.assign_memory_index(
|
||||
base_value,
|
||||
index_value,
|
||||
byte_value,
|
||||
Some(*span),
|
||||
frame,
|
||||
)?;
|
||||
}
|
||||
},
|
||||
Stmt::Eval { expr, .. } => {
|
||||
self.eval_expr(expr, frame)?;
|
||||
}
|
||||
@@ -417,6 +454,62 @@ impl<'a> Interpreter<'a> {
|
||||
self.call_by_name_from(&module, &name, args, Some(span), Some(&caller))
|
||||
}
|
||||
|
||||
/// Commit one byte into an addressable region after all operand checks.
|
||||
///
|
||||
/// The three operands are already evaluated, so a rejected value never
|
||||
/// produces a partial write (ADR-0022 §3).
|
||||
fn assign_memory_index(
|
||||
&mut self,
|
||||
base: Value,
|
||||
index: Value,
|
||||
byte: Value,
|
||||
span: Option<Span>,
|
||||
frame: &Frame,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let base_type = base.type_name();
|
||||
let Value::Memory(handle) = base else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::Type,
|
||||
span,
|
||||
format!(
|
||||
"index assignment requires a Memory base in v1, got {base_type}; List, Map \
|
||||
and Table values keep their existing value semantics"
|
||||
),
|
||||
));
|
||||
};
|
||||
let index_type = index.type_name();
|
||||
let Value::Int(offset) = index else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("Memory index must be an Int, got {index_type}"),
|
||||
));
|
||||
};
|
||||
let byte_type = byte.type_name();
|
||||
let byte_repr = byte.display();
|
||||
let Value::Int(byte) = byte else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("Memory byte value must be an Int in 0..255, got {byte_type}"),
|
||||
));
|
||||
};
|
||||
let Some(byte) = num_traits::ToPrimitive::to_u8(&byte) else {
|
||||
return Err(RuntimeError::type_error(
|
||||
span,
|
||||
format!("Memory byte value {byte_repr} is outside 0..255"),
|
||||
));
|
||||
};
|
||||
self.memory.write(handle, &offset, byte, span)?;
|
||||
let module = frame.function.module.canonical();
|
||||
self.host.record_semantic(
|
||||
"memory.write",
|
||||
Some(&frame.function.to_string()),
|
||||
Some(&module),
|
||||
span,
|
||||
Some("byte"),
|
||||
);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn eval_args(
|
||||
&mut self,
|
||||
args: &[marqdo_expression::Arg],
|
||||
@@ -528,7 +621,22 @@ impl<'a> Interpreter<'a> {
|
||||
Expr::Index { base, index, span } => {
|
||||
let base_value = self.eval_expr(base, frame)?;
|
||||
let index_value = self.eval_expr(index, frame)?;
|
||||
index_value_of(base_value, index_value, Some(*span))
|
||||
match base_value {
|
||||
Value::Memory(handle) => {
|
||||
let Value::Int(offset) = index_value else {
|
||||
return Err(RuntimeError::type_error(
|
||||
Some(*span),
|
||||
format!(
|
||||
"Memory index must be an Int, got {}",
|
||||
index_value.type_name()
|
||||
),
|
||||
));
|
||||
};
|
||||
let byte = self.memory.read(handle, &offset, Some(*span))?;
|
||||
Ok(Value::int(i64::from(byte)))
|
||||
}
|
||||
other => index_value_of(other, index_value, Some(*span)),
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -701,6 +809,97 @@ impl<'a> Interpreter<'a> {
|
||||
self.program
|
||||
}
|
||||
|
||||
/// Addressable-memory store for builtins and place writes.
|
||||
pub(crate) fn memory(&self) -> &MemoryStore {
|
||||
&self.memory
|
||||
}
|
||||
|
||||
/// Mutable addressable-memory store for `memory.new`/`memory.grow`.
|
||||
pub(crate) fn memory_mut(&mut self) -> &mut MemoryStore {
|
||||
&mut self.memory
|
||||
}
|
||||
|
||||
/// Record a semantic event for a builtin that is not a host operation.
|
||||
pub(crate) fn record_memory_event(
|
||||
&mut self,
|
||||
kind: &str,
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
detail: &str,
|
||||
) {
|
||||
let module = module.canonical();
|
||||
self.host
|
||||
.record_semantic(kind, None, Some(&module), span, Some(detail));
|
||||
}
|
||||
|
||||
/// Open a resource/stream through the host boundary.
|
||||
pub(crate) fn resource_open(
|
||||
&mut self,
|
||||
kind: &str,
|
||||
descriptor: &str,
|
||||
rights: &[String],
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
) -> Result<Value, RuntimeError> {
|
||||
let context = ExecutionContext::new(module.to_string(), span);
|
||||
self.host
|
||||
.resource_open(kind, descriptor, rights, &context)
|
||||
.map_err(|mut error| {
|
||||
error.mark_callsite();
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
/// Read from a resource stream.
|
||||
pub(crate) fn resource_read(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
max_bytes: usize,
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
) -> Result<ResourceRead, RuntimeError> {
|
||||
let context = ExecutionContext::new(module.to_string(), span);
|
||||
self.host
|
||||
.resource_read(handle, max_bytes, &context)
|
||||
.map_err(|mut error| {
|
||||
error.mark_callsite();
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
/// Write bytes to a resource stream.
|
||||
pub(crate) fn resource_write(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
bytes: &[u8],
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
let context = ExecutionContext::new(module.to_string(), span);
|
||||
self.host
|
||||
.resource_write(handle, bytes, &context)
|
||||
.map_err(|mut error| {
|
||||
error.mark_callsite();
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
/// Close a resource stream.
|
||||
pub(crate) fn resource_close(
|
||||
&mut self,
|
||||
handle: ResourceHandle,
|
||||
module: &ModuleId,
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let context = ExecutionContext::new(module.to_string(), span);
|
||||
self.host
|
||||
.resource_close(handle, &context)
|
||||
.map_err(|mut error| {
|
||||
error.mark_callsite();
|
||||
error
|
||||
})
|
||||
}
|
||||
|
||||
/// Call a builtin-read host operation on behalf of a frame's module.
|
||||
pub(crate) fn host_invoke(
|
||||
&mut self,
|
||||
|
||||
@@ -8,8 +8,12 @@
|
||||
|
||||
mod builtins_impl;
|
||||
mod interpreter;
|
||||
mod memory;
|
||||
mod value_ops;
|
||||
|
||||
pub use interpreter::{run, EvaluatedArg, Interpreter, RunOutcome};
|
||||
pub use interpreter::{run, run_with_limits, EvaluatedArg, Interpreter, RunOutcome};
|
||||
pub use memory::{
|
||||
MemoryLimits, MemoryStore, DEFAULT_MAX_REGION_BYTES, DEFAULT_MAX_TOTAL_BYTES, PAGE_SIZE,
|
||||
};
|
||||
|
||||
pub use marqdo_value::{RuntimeError, Value};
|
||||
@@ -0,0 +1,600 @@
|
||||
//! Runtime-owned addressable byte regions (RFC-CM-0001 / ADR-0022).
|
||||
//!
|
||||
//! A [`MemoryStore`] owns every region created during one run. Language values
|
||||
//! carry only an opaque [`MemoryHandle`]; offsets are region-relative integers
|
||||
//! and are never host pointers. Region identity is issued here and cannot be
|
||||
//! forged from a document, a number or wire data.
|
||||
//!
|
||||
//! Semantics frozen by ADR-0022:
|
||||
//!
|
||||
//! * a region is a byte array with a 64 KiB logical page size; new bytes are
|
||||
//! zero-filled;
|
||||
//! * regions grow only, never shrink; a failed grow leaves the region and the
|
||||
//! committed budget unchanged;
|
||||
//! * copies of a `Memory` value share one region, while different regions
|
||||
//! never alias;
|
||||
//! * every access is bounds-checked against the region and the run budget, and
|
||||
//! overflow in offset/page arithmetic is a structured error, never a panic;
|
||||
//! * regions live for the whole run and are dropped with the store. There is
|
||||
//! no user-visible `free(region)`.
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
use std::sync::atomic::{AtomicU64, Ordering};
|
||||
|
||||
use marqdo_span::Span;
|
||||
use marqdo_value::{ErrorCategory, MemoryHandle, RuntimeError};
|
||||
use num_bigint::BigInt;
|
||||
use num_traits::ToPrimitive;
|
||||
|
||||
/// Logical page size for every region.
|
||||
pub const PAGE_SIZE: usize = 64 * 1024;
|
||||
|
||||
/// Default maximum committed bytes across all regions in one run (64 MiB).
|
||||
pub const DEFAULT_MAX_TOTAL_BYTES: usize = 64 * 1024 * 1024;
|
||||
|
||||
/// Default maximum committed bytes for one region (16 MiB).
|
||||
pub const DEFAULT_MAX_REGION_BYTES: usize = 16 * 1024 * 1024;
|
||||
|
||||
static NEXT_RUN_ID: AtomicU64 = AtomicU64::new(1);
|
||||
|
||||
/// Bounds for addressable memory in one run.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
||||
pub struct MemoryLimits {
|
||||
/// Maximum bytes committed across all live regions.
|
||||
pub max_total_bytes: usize,
|
||||
/// Maximum bytes committed by a single region (`max_pages` is further
|
||||
/// capped by this value).
|
||||
pub max_region_bytes: usize,
|
||||
}
|
||||
|
||||
impl Default for MemoryLimits {
|
||||
fn default() -> Self {
|
||||
Self {
|
||||
max_total_bytes: DEFAULT_MAX_TOTAL_BYTES,
|
||||
max_region_bytes: DEFAULT_MAX_REGION_BYTES,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl MemoryLimits {
|
||||
/// Maximum page count a single region may declare or reach.
|
||||
pub fn max_region_pages(&self) -> u64 {
|
||||
(self.max_region_bytes / PAGE_SIZE) as u64
|
||||
}
|
||||
}
|
||||
|
||||
struct Region {
|
||||
bytes: Vec<u8>,
|
||||
/// Declared maximum size for this region.
|
||||
max_bytes: usize,
|
||||
generation: u64,
|
||||
}
|
||||
|
||||
/// All addressable regions created by one run.
|
||||
pub struct MemoryStore {
|
||||
run_id: u64,
|
||||
next_region: u64,
|
||||
regions: BTreeMap<u64, Region>,
|
||||
committed_bytes: usize,
|
||||
limits: MemoryLimits,
|
||||
}
|
||||
|
||||
impl MemoryStore {
|
||||
/// Create an empty store with a fresh, unguessable run identity.
|
||||
pub fn new(limits: MemoryLimits) -> Self {
|
||||
Self {
|
||||
run_id: NEXT_RUN_ID.fetch_add(1, Ordering::Relaxed),
|
||||
next_region: 1,
|
||||
regions: BTreeMap::new(),
|
||||
committed_bytes: 0,
|
||||
limits,
|
||||
}
|
||||
}
|
||||
|
||||
/// Limits in force for this store.
|
||||
pub fn limits(&self) -> MemoryLimits {
|
||||
self.limits
|
||||
}
|
||||
|
||||
/// Bytes currently committed across all regions.
|
||||
pub fn committed_bytes(&self) -> usize {
|
||||
self.committed_bytes
|
||||
}
|
||||
|
||||
/// Number of live regions.
|
||||
pub fn region_count(&self) -> usize {
|
||||
self.regions.len()
|
||||
}
|
||||
|
||||
/// Create a zero-filled region.
|
||||
///
|
||||
/// `initial_pages` is committed immediately; `max_pages` is the declared
|
||||
/// capacity that `grow` may not exceed. Both are checked against the
|
||||
/// region and total budgets before anything is allocated, so a rejected
|
||||
/// create leaves the store unchanged.
|
||||
pub fn create(
|
||||
&mut self,
|
||||
initial_pages: u64,
|
||||
max_pages: u64,
|
||||
span: Option<Span>,
|
||||
) -> Result<MemoryHandle, RuntimeError> {
|
||||
if initial_pages > max_pages {
|
||||
return Err(memory_error(
|
||||
span,
|
||||
format!(
|
||||
"memory.new initial_pages ({initial_pages}) must not exceed max_pages \
|
||||
({max_pages})"
|
||||
),
|
||||
));
|
||||
}
|
||||
if max_pages > self.limits.max_region_pages() {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory.new max_pages ({max_pages}) exceeds the per-region limit of {} \
|
||||
pages ({PAGE_SIZE} bytes each)",
|
||||
self.limits.max_region_pages()
|
||||
),
|
||||
));
|
||||
}
|
||||
let max_bytes = checked_bytes(max_pages, span, "region capacity")?;
|
||||
if max_bytes > self.limits.max_region_bytes {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory.new max_pages ({max_pages}) exceeds the per-region byte budget of {}",
|
||||
self.limits.max_region_bytes
|
||||
),
|
||||
));
|
||||
}
|
||||
let initial_bytes = checked_bytes(initial_pages, span, "initial region size")?;
|
||||
let committed = self
|
||||
.committed_bytes
|
||||
.checked_add(initial_bytes)
|
||||
.ok_or_else(|| budget_error(span, "memory budget overflow"))?;
|
||||
if committed > self.limits.max_total_bytes {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory budget exceeded: committing {initial_bytes} bytes would reach \
|
||||
{committed} of {}",
|
||||
self.limits.max_total_bytes
|
||||
),
|
||||
));
|
||||
}
|
||||
|
||||
let mut bytes = Vec::new();
|
||||
bytes.try_reserve_exact(initial_bytes).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!("cannot allocate {initial_bytes} bytes of addressable memory"),
|
||||
)
|
||||
})?;
|
||||
bytes.resize(initial_bytes, 0);
|
||||
|
||||
let region_id = self.next_region;
|
||||
self.next_region = self
|
||||
.next_region
|
||||
.checked_add(1)
|
||||
.ok_or_else(|| memory_error(span, "memory region identity space exhausted"))?;
|
||||
self.regions.insert(
|
||||
region_id,
|
||||
Region {
|
||||
bytes,
|
||||
max_bytes,
|
||||
generation: 1,
|
||||
},
|
||||
);
|
||||
self.committed_bytes = committed;
|
||||
Ok(MemoryHandle::from_runtime(self.run_id, region_id, 1))
|
||||
}
|
||||
|
||||
/// Current length of a region in pages.
|
||||
pub fn size(&self, handle: MemoryHandle, span: Option<Span>) -> Result<u64, RuntimeError> {
|
||||
let region = self.region(handle, span)?;
|
||||
Ok((region.bytes.len() / PAGE_SIZE) as u64)
|
||||
}
|
||||
|
||||
/// Grow a region by whole pages and return its previous page count.
|
||||
///
|
||||
/// A failed grow is atomic: the region keeps its old length and bytes and
|
||||
/// the committed budget is unchanged.
|
||||
pub fn grow(
|
||||
&mut self,
|
||||
handle: MemoryHandle,
|
||||
pages: u64,
|
||||
span: Option<Span>,
|
||||
) -> Result<u64, RuntimeError> {
|
||||
if pages == 0 {
|
||||
return self.size(handle, span);
|
||||
}
|
||||
let region = self.region(handle, span)?;
|
||||
let old_bytes = region.bytes.len();
|
||||
let old_pages = (old_bytes / PAGE_SIZE) as u64;
|
||||
let additional = checked_bytes(pages, span, "memory.grow pages")?;
|
||||
let new_bytes = old_bytes
|
||||
.checked_add(additional)
|
||||
.ok_or_else(|| memory_error(span, "memory.grow size overflows the address space"))?;
|
||||
if new_bytes > region.max_bytes {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory.grow would grow the region to {new_bytes} bytes, beyond its \
|
||||
declared maximum of {} bytes",
|
||||
region.max_bytes
|
||||
),
|
||||
));
|
||||
}
|
||||
let committed = self
|
||||
.committed_bytes
|
||||
.checked_add(additional)
|
||||
.ok_or_else(|| budget_error(span, "memory budget overflow"))?;
|
||||
if committed > self.limits.max_total_bytes {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!(
|
||||
"memory budget exceeded: growing by {additional} bytes would reach \
|
||||
{committed} of {}",
|
||||
self.limits.max_total_bytes
|
||||
),
|
||||
));
|
||||
}
|
||||
|
||||
let region = self
|
||||
.regions
|
||||
.get_mut(&handle.region_id())
|
||||
.ok_or_else(|| memory_error(span, "unknown Memory region handle"))?;
|
||||
region.bytes.try_reserve(additional).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!("cannot grow addressable memory by {additional} bytes"),
|
||||
)
|
||||
})?;
|
||||
region.bytes.resize(new_bytes, 0);
|
||||
self.committed_bytes = committed;
|
||||
Ok(old_pages)
|
||||
}
|
||||
|
||||
/// Total byte length of a region.
|
||||
pub fn byte_len(
|
||||
&self,
|
||||
handle: MemoryHandle,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
Ok(self.region(handle, span)?.bytes.len())
|
||||
}
|
||||
|
||||
/// Read a contiguous byte range. Used by resource I/O adapters.
|
||||
pub fn read_bytes(
|
||||
&self,
|
||||
handle: MemoryHandle,
|
||||
offset: &BigInt,
|
||||
length: usize,
|
||||
span: Option<Span>,
|
||||
) -> Result<Vec<u8>, RuntimeError> {
|
||||
let region = self.region(handle, span)?;
|
||||
let start = range_offset(offset, region.bytes.len(), length, span)?;
|
||||
Ok(region.bytes[start..start + length].to_vec())
|
||||
}
|
||||
|
||||
/// Write a contiguous byte range atomically after a full bounds check.
|
||||
pub fn write_bytes(
|
||||
&mut self,
|
||||
handle: MemoryHandle,
|
||||
offset: &BigInt,
|
||||
bytes: &[u8],
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let len = self.region(handle, span)?.bytes.len();
|
||||
let start = range_offset(offset, len, bytes.len(), span)?;
|
||||
let region = self
|
||||
.regions
|
||||
.get_mut(&handle.region_id())
|
||||
.ok_or_else(|| memory_error(span, "unknown Memory region handle"))?;
|
||||
region.bytes[start..start + bytes.len()].copy_from_slice(bytes);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Read one byte. Offsets are non-negative and region-relative.
|
||||
pub fn read(
|
||||
&self,
|
||||
handle: MemoryHandle,
|
||||
offset: &BigInt,
|
||||
span: Option<Span>,
|
||||
) -> Result<u8, RuntimeError> {
|
||||
let region = self.region(handle, span)?;
|
||||
let position = checked_offset(offset, region.bytes.len(), span)?;
|
||||
Ok(region.bytes[position])
|
||||
}
|
||||
|
||||
/// Write one byte. The caller must have validated the byte range.
|
||||
pub fn write(
|
||||
&mut self,
|
||||
handle: MemoryHandle,
|
||||
offset: &BigInt,
|
||||
byte: u8,
|
||||
span: Option<Span>,
|
||||
) -> Result<(), RuntimeError> {
|
||||
let len = self.region(handle, span)?.bytes.len();
|
||||
let position = checked_offset(offset, len, span)?;
|
||||
let region = self
|
||||
.regions
|
||||
.get_mut(&handle.region_id())
|
||||
.ok_or_else(|| memory_error(span, "unknown Memory region handle"))?;
|
||||
region.bytes[position] = byte;
|
||||
Ok(())
|
||||
}
|
||||
|
||||
fn region(&self, handle: MemoryHandle, span: Option<Span>) -> Result<&Region, RuntimeError> {
|
||||
if handle.run_id() != self.run_id {
|
||||
return Err(memory_error(
|
||||
span,
|
||||
"Memory handle belongs to a different execution run",
|
||||
));
|
||||
}
|
||||
let Some(region) = self.regions.get(&handle.region_id()) else {
|
||||
return Err(memory_error(span, "unknown Memory region handle"));
|
||||
};
|
||||
if region.generation != handle.generation() {
|
||||
return Err(memory_error(span, "stale Memory region handle"));
|
||||
}
|
||||
Ok(region)
|
||||
}
|
||||
}
|
||||
|
||||
fn checked_bytes(pages: u64, span: Option<Span>, what: &str) -> Result<usize, RuntimeError> {
|
||||
let bytes = pages
|
||||
.checked_mul(PAGE_SIZE as u64)
|
||||
.ok_or_else(|| memory_error(span, format!("{what} overflows the address space")))?;
|
||||
usize::try_from(bytes).map_err(|_| {
|
||||
RuntimeError::new(
|
||||
ErrorCategory::ResourceExhausted,
|
||||
span,
|
||||
format!("{what} ({pages} pages) does not fit this platform's address space"),
|
||||
)
|
||||
})
|
||||
}
|
||||
|
||||
/// Validate an offset plus a byte count against the region length.
|
||||
fn range_offset(
|
||||
offset: &BigInt,
|
||||
len: usize,
|
||||
length: usize,
|
||||
span: Option<Span>,
|
||||
) -> Result<usize, RuntimeError> {
|
||||
if offset.sign() == num_bigint::Sign::Minus {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
"Memory offset must be a non-negative integer",
|
||||
));
|
||||
}
|
||||
let Some(start) = offset.to_usize() else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("Memory offset {offset} is out of bounds for region length {len}"),
|
||||
));
|
||||
};
|
||||
let end = start.checked_add(length).ok_or_else(|| {
|
||||
memory_error(
|
||||
span,
|
||||
"Memory offset plus length overflows the address space",
|
||||
)
|
||||
})?;
|
||||
if end > len {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("Memory range {start}..{end} is out of bounds for region length {len}"),
|
||||
));
|
||||
}
|
||||
Ok(start)
|
||||
}
|
||||
|
||||
fn checked_offset(offset: &BigInt, len: usize, span: Option<Span>) -> Result<usize, RuntimeError> {
|
||||
if offset.sign() == num_bigint::Sign::Minus {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
"Memory offset must be a non-negative integer",
|
||||
));
|
||||
}
|
||||
let Some(position) = offset.to_usize() else {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("Memory offset {offset} is out of bounds for region length {len}"),
|
||||
));
|
||||
};
|
||||
if position >= len {
|
||||
return Err(RuntimeError::new(
|
||||
ErrorCategory::IndexOutOfBounds,
|
||||
span,
|
||||
format!("Memory offset {offset} is out of bounds for region length {len}"),
|
||||
));
|
||||
}
|
||||
Ok(position)
|
||||
}
|
||||
|
||||
fn memory_error(span: Option<Span>, message: impl Into<String>) -> RuntimeError {
|
||||
RuntimeError::new(ErrorCategory::MemoryFault, span, message)
|
||||
}
|
||||
|
||||
fn budget_error(span: Option<Span>, message: impl Into<String>) -> RuntimeError {
|
||||
RuntimeError::new(ErrorCategory::ResourceExhausted, span, message)
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
fn int(value: impl Into<BigInt>) -> BigInt {
|
||||
value.into()
|
||||
}
|
||||
|
||||
fn store() -> MemoryStore {
|
||||
MemoryStore::new(MemoryLimits::default())
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn regions_are_isolated_and_handles_share_identity() {
|
||||
let mut store = store();
|
||||
let first = store.create(1, 2, None).unwrap();
|
||||
let second = store.create(1, 2, None).unwrap();
|
||||
let alias = first;
|
||||
store.write(first, &int(0), 7, None).unwrap();
|
||||
store.write(second, &int(0), 9, None).unwrap();
|
||||
assert_eq!(store.read(first, &int(0), None).unwrap(), 7);
|
||||
assert_eq!(store.read(alias, &int(0), None).unwrap(), 7);
|
||||
assert_eq!(store.read(second, &int(0), None).unwrap(), 9);
|
||||
assert_eq!(first, alias);
|
||||
assert_ne!(first, second);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn create_is_zero_filled_and_reports_pages() {
|
||||
let mut store = store();
|
||||
let memory = store.create(1, 4, None).unwrap();
|
||||
assert_eq!(store.size(memory, None).unwrap(), 1);
|
||||
assert_eq!(PAGE_SIZE, 64 * 1024);
|
||||
for offset in [0usize, 1, PAGE_SIZE - 1] {
|
||||
assert_eq!(store.read(memory, &int(offset as u64), None).unwrap(), 0);
|
||||
}
|
||||
// Zero-page creation is legal but every access is out of bounds.
|
||||
let empty = store.create(0, 1, None).unwrap();
|
||||
assert_eq!(store.size(empty, None).unwrap(), 0);
|
||||
assert_eq!(
|
||||
store.read(empty, &int(0), None).unwrap_err().category,
|
||||
ErrorCategory::IndexOutOfBounds
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn grow_keeps_old_bytes_and_zero_fills_new_pages() {
|
||||
let mut store = store();
|
||||
let memory = store.create(1, 2, None).unwrap();
|
||||
store.write(memory, &int(3), 200, None).unwrap();
|
||||
assert_eq!(store.grow(memory, 1, None).unwrap(), 1);
|
||||
assert_eq!(store.size(memory, None).unwrap(), 2);
|
||||
assert_eq!(store.read(memory, &int(3), None).unwrap(), 200);
|
||||
assert_eq!(store.read(memory, &int(PAGE_SIZE as u64), None).unwrap(), 0);
|
||||
store
|
||||
.write(memory, &int(PAGE_SIZE as u64 + 5), 42, None)
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
store
|
||||
.read(memory, &int(PAGE_SIZE as u64 + 5), None)
|
||||
.unwrap(),
|
||||
42
|
||||
);
|
||||
// Zero-page growth is a no-op returning the old count.
|
||||
assert_eq!(store.grow(memory, 0, None).unwrap(), 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn failed_grow_does_not_change_region_or_budget() {
|
||||
let mut store = MemoryStore::new(MemoryLimits {
|
||||
max_total_bytes: PAGE_SIZE * 2,
|
||||
max_region_bytes: PAGE_SIZE * 4,
|
||||
});
|
||||
let memory = store.create(1, 2, None).unwrap();
|
||||
store.write(memory, &int(0), 1, None).unwrap();
|
||||
let before = store.committed_bytes();
|
||||
let error = store.grow(memory, 2, None).unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::ResourceExhausted);
|
||||
assert_eq!(store.size(memory, None).unwrap(), 1);
|
||||
assert_eq!(store.read(memory, &int(0), None).unwrap(), 1);
|
||||
assert_eq!(store.committed_bytes(), before);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn invalid_offsets_are_structured_errors() {
|
||||
let mut store = store();
|
||||
let memory = store.create(1, 1, None).unwrap();
|
||||
for offset in [int(-1), int(PAGE_SIZE as u64)] {
|
||||
let error = store.read(memory, &offset, None).unwrap_err();
|
||||
assert_eq!(error.category, ErrorCategory::IndexOutOfBounds);
|
||||
}
|
||||
let huge: BigInt = "999999999999999999999999999999999999999".parse().unwrap();
|
||||
assert_eq!(
|
||||
store.read(memory, &huge, None).unwrap_err().category,
|
||||
ErrorCategory::IndexOutOfBounds
|
||||
);
|
||||
assert_eq!(
|
||||
store.write(memory, &huge, 1, None).unwrap_err().category,
|
||||
ErrorCategory::IndexOutOfBounds
|
||||
);
|
||||
assert_eq!(
|
||||
store
|
||||
.write(memory, &int(PAGE_SIZE as u64), 1, None)
|
||||
.unwrap_err()
|
||||
.category,
|
||||
ErrorCategory::IndexOutOfBounds
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn create_validates_page_counts_and_budget() {
|
||||
let mut store = MemoryStore::new(MemoryLimits {
|
||||
max_total_bytes: PAGE_SIZE * 3,
|
||||
max_region_bytes: PAGE_SIZE * 2,
|
||||
});
|
||||
assert_eq!(
|
||||
store.create(2, 1, None).unwrap_err().category,
|
||||
ErrorCategory::MemoryFault
|
||||
);
|
||||
assert_eq!(
|
||||
store.create(1, 3, None).unwrap_err().category,
|
||||
ErrorCategory::ResourceExhausted
|
||||
);
|
||||
let _first = store.create(2, 2, None).unwrap();
|
||||
let _second = store.create(1, 1, None).unwrap();
|
||||
// Total budget is now exactly three pages.
|
||||
assert_eq!(
|
||||
store.create(1, 1, None).unwrap_err().category,
|
||||
ErrorCategory::ResourceExhausted
|
||||
);
|
||||
assert_eq!(store.committed_bytes(), PAGE_SIZE * 3);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn forged_and_stale_handles_are_rejected() {
|
||||
let mut store = store();
|
||||
let memory = store.create(1, 1, None).unwrap();
|
||||
let forged = MemoryHandle::from_runtime(memory.run_id() + 1, memory.region_id(), 1);
|
||||
assert_eq!(
|
||||
store.read(forged, &int(0), None).unwrap_err().category,
|
||||
ErrorCategory::MemoryFault
|
||||
);
|
||||
let stale = MemoryHandle::from_runtime(memory.run_id(), memory.region_id(), 2);
|
||||
assert_eq!(
|
||||
store.read(stale, &int(0), None).unwrap_err().category,
|
||||
ErrorCategory::MemoryFault
|
||||
);
|
||||
let unknown = MemoryHandle::from_runtime(memory.run_id(), 999, 1);
|
||||
assert_eq!(
|
||||
store.write(unknown, &int(0), 1, None).unwrap_err().category,
|
||||
ErrorCategory::MemoryFault
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn page_arithmetic_never_overflows() {
|
||||
let mut store = MemoryStore::new(MemoryLimits {
|
||||
max_total_bytes: usize::MAX,
|
||||
max_region_bytes: usize::MAX,
|
||||
});
|
||||
assert_eq!(
|
||||
store.create(u64::MAX, u64::MAX, None).unwrap_err().category,
|
||||
ErrorCategory::ResourceExhausted
|
||||
);
|
||||
}
|
||||
}
|
||||
@@ -107,6 +107,32 @@ fn compare(
|
||||
}
|
||||
}))
|
||||
}
|
||||
(Value::Resource(a), Value::Resource(b)) => {
|
||||
return Ok(Value::Bool(match op {
|
||||
BinaryOp::Eq => a == b,
|
||||
BinaryOp::Ne => a != b,
|
||||
_ => {
|
||||
return Err(type_error(
|
||||
span,
|
||||
"Resource ordering comparisons are not supported".to_string(),
|
||||
))
|
||||
}
|
||||
}));
|
||||
}
|
||||
(Value::Memory(a), Value::Memory(b)) => {
|
||||
// Identity, not byte content: two handles for the same region are
|
||||
// equal, regions with identical bytes are not (ADR-0022 §1).
|
||||
return Ok(Value::Bool(match op {
|
||||
BinaryOp::Eq => a == b,
|
||||
BinaryOp::Ne => a != b,
|
||||
_ => {
|
||||
return Err(type_error(
|
||||
span,
|
||||
"Memory ordering comparisons are not supported".to_string(),
|
||||
))
|
||||
}
|
||||
}));
|
||||
}
|
||||
(a, b) => {
|
||||
if op == BinaryOp::Eq {
|
||||
return Ok(Value::Bool(false));
|
||||
|
||||
@@ -2,7 +2,7 @@
|
||||
|
||||
use marqdo_host::{Capabilities, Host, StdHost};
|
||||
use marqdo_ir::{ModuleId, Program};
|
||||
use marqdo_runtime::{run, EvaluatedArg, RuntimeError, Value};
|
||||
use marqdo_runtime::{run, run_with_limits, EvaluatedArg, MemoryLimits, RuntimeError, Value};
|
||||
use marqdo_sandbox::SandboxMode;
|
||||
use marqdo_span::Span;
|
||||
|
||||
@@ -170,3 +170,46 @@ fn ambiguous_ref_resource_is_an_error() {
|
||||
let error = run_named(source, "f", &[]).unwrap_err();
|
||||
assert_eq!(error.code(), "ref.ambiguous");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn memory_region_is_shared_by_handle_identity() {
|
||||
let source = "## f\n\n**m = memory.new(1, 2)**\n\n**n = m**\n\n**`m[3] = 7`**\n\n*[n[3], m == n, memory.size(n)]*\n";
|
||||
let value = run_named(source, "f", &[]).unwrap();
|
||||
assert_eq!(
|
||||
value,
|
||||
Value::List(vec![Value::int(7), Value::Bool(true), Value::int(1)])
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn memory_handle_cannot_reach_the_host_boundary() {
|
||||
let source = "## f\n\n**m = memory.new(1, 1)**\n\n> 打印(m)\n\n*0*\n";
|
||||
let error = run_named(source, "f", &[]).unwrap_err();
|
||||
assert_eq!(error.code(), "runtime.type");
|
||||
assert!(
|
||||
error
|
||||
.message
|
||||
.contains("Memory values cannot cross the host boundary"),
|
||||
"unexpected message: {}",
|
||||
error.message
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn memory_budget_is_enforced_without_changing_the_region() {
|
||||
let program = build("## f\n\n**m = memory.new(1, 1)**\n\n*[m[0], memory.grow(m, 1)]*\n");
|
||||
let mut host = host();
|
||||
let error = run_with_limits(
|
||||
&program,
|
||||
&mut host,
|
||||
&ModuleId::from("index.mq.md"),
|
||||
"f",
|
||||
Vec::new(),
|
||||
MemoryLimits {
|
||||
max_total_bytes: 64 * 1024,
|
||||
max_region_bytes: 64 * 1024 * 2,
|
||||
},
|
||||
)
|
||||
.unwrap_err();
|
||||
assert_eq!(error.code(), "resource.exhausted");
|
||||
}
|
||||
@@ -23,8 +23,19 @@ pub enum ErrorCategory {
|
||||
NotCallable,
|
||||
/// A map key or record field does not exist.
|
||||
UnknownField,
|
||||
/// A list/map index is out of bounds.
|
||||
/// A list/map/memory index is out of bounds.
|
||||
IndexOutOfBounds,
|
||||
/// An addressable-memory operation failed for a reason other than a plain
|
||||
/// out-of-bounds read: invalid page counts, an unknown/stale handle, or an
|
||||
/// arithmetic overflow in an address.
|
||||
MemoryFault,
|
||||
/// A resource handle is forged, cross-run or stale.
|
||||
ResourceFault,
|
||||
/// A resource operation used an already-closed handle (recoverable as a
|
||||
/// `Result` by the builtin).
|
||||
ResourceClosed,
|
||||
/// The requested resource kind/descriptor/rights are not implemented.
|
||||
ResourceUnsupported,
|
||||
/// A resource budget was exhausted (fuel, stack, output size).
|
||||
ResourceExhausted,
|
||||
/// A capability check denied the operation.
|
||||
@@ -60,6 +71,10 @@ impl ErrorCategory {
|
||||
ErrorCategory::NotCallable => "call.not_callable",
|
||||
ErrorCategory::UnknownField => "runtime.unknown_field",
|
||||
ErrorCategory::IndexOutOfBounds => codes::RUNTIME_INDEX,
|
||||
ErrorCategory::MemoryFault => "runtime.memory",
|
||||
ErrorCategory::ResourceFault => "runtime.resource",
|
||||
ErrorCategory::ResourceClosed => "resource.closed",
|
||||
ErrorCategory::ResourceUnsupported => "resource.unsupported",
|
||||
ErrorCategory::ResourceExhausted => codes::RESOURCE_EXHAUSTED,
|
||||
ErrorCategory::PermissionDenied => codes::PERMISSION_DENIED,
|
||||
ErrorCategory::KernelUnavailable => codes::KERNEL_UNAVAILABLE,
|
||||
|
||||
@@ -15,6 +15,6 @@ pub use error::{CallFrame, ErrorCategory, RuntimeError};
|
||||
pub use marqdo_span::{LineCol, Span};
|
||||
pub use value::{
|
||||
bigint_to_exact_f64, float_to_bigint, format_float, CodeValue, FormulaValue, FunctionRef,
|
||||
PluginHandle, Table, Value,
|
||||
MemoryHandle, PluginHandle, ResourceHandle, Table, Value,
|
||||
};
|
||||
pub use wire::{from_wire, to_wire, WireError, WIRE_VERSION};
|
||||
@@ -75,6 +75,88 @@ pub struct PluginHandle {
|
||||
pub id: u64,
|
||||
}
|
||||
|
||||
/// Opaque identity of one runtime-managed byte region (ADR-0022).
|
||||
///
|
||||
/// A handle is issued only by the runtime's `MemoryStore`. Copying a `Memory`
|
||||
/// value or passing it as an argument preserves this identity, so two names
|
||||
/// can observe each other's writes. The fields are deliberately not part of
|
||||
/// any wire format: [`crate::wire`] rejects the `memory` tag on decode, and no
|
||||
/// public constructor accepts untrusted data. There is no `usize` address in
|
||||
/// the language value; offsets are region-relative integers.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub struct MemoryHandle {
|
||||
run: u64,
|
||||
region: u64,
|
||||
generation: u64,
|
||||
}
|
||||
|
||||
impl MemoryHandle {
|
||||
/// Create a handle. Only the runtime store may call this; users cannot
|
||||
/// construct one from a number, a document or wire data.
|
||||
#[doc(hidden)]
|
||||
pub const fn from_runtime(run: u64, region: u64, generation: u64) -> Self {
|
||||
Self {
|
||||
run,
|
||||
region,
|
||||
generation,
|
||||
}
|
||||
}
|
||||
|
||||
/// Run identity this region belongs to.
|
||||
pub const fn run_id(&self) -> u64 {
|
||||
self.run
|
||||
}
|
||||
|
||||
/// Region identity within the run.
|
||||
pub const fn region_id(&self) -> u64 {
|
||||
self.region
|
||||
}
|
||||
|
||||
/// Generation of the region slot (guards a future reuse policy).
|
||||
pub const fn generation(&self) -> u64 {
|
||||
self.generation
|
||||
}
|
||||
}
|
||||
|
||||
/// Opaque host-issued handle to an external resource/stream (ADR-0025).
|
||||
///
|
||||
/// Fields are private and the constructor is host-only. A handle is never
|
||||
/// built from wire data or a user integer; it is a different domain from
|
||||
/// `Memory` and cannot be indexed.
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
|
||||
pub struct ResourceHandle {
|
||||
run: u64,
|
||||
resource: u64,
|
||||
generation: u64,
|
||||
}
|
||||
|
||||
impl ResourceHandle {
|
||||
/// Host-only constructor.
|
||||
#[doc(hidden)]
|
||||
pub const fn from_host(run: u64, resource: u64, generation: u64) -> Self {
|
||||
Self {
|
||||
run,
|
||||
resource,
|
||||
generation,
|
||||
}
|
||||
}
|
||||
|
||||
/// Host run identity.
|
||||
pub const fn run_id(&self) -> u64 {
|
||||
self.run
|
||||
}
|
||||
|
||||
/// Resource slot identity.
|
||||
pub const fn resource_id(&self) -> u64 {
|
||||
self.resource
|
||||
}
|
||||
|
||||
/// Slot generation.
|
||||
pub const fn generation(&self) -> u64 {
|
||||
self.generation
|
||||
}
|
||||
}
|
||||
|
||||
/// A Marqdo runtime value.
|
||||
#[derive(Debug, Clone, PartialEq)]
|
||||
pub enum Value {
|
||||
@@ -104,6 +186,11 @@ pub enum Value {
|
||||
FunctionRef(FunctionRef),
|
||||
/// Host-owned plugin handle.
|
||||
PluginHandle(PluginHandle),
|
||||
/// Runtime-owned addressable byte region (RFC-CM-0001). Copies share the
|
||||
/// same region identity; they are not byte snapshots.
|
||||
Memory(MemoryHandle),
|
||||
/// Host-owned external resource/stream handle (ADR-0025).
|
||||
Resource(ResourceHandle),
|
||||
}
|
||||
|
||||
impl Value {
|
||||
@@ -123,6 +210,8 @@ impl Value {
|
||||
Value::Code(_) => "Code",
|
||||
Value::FunctionRef(_) => "FunctionRef",
|
||||
Value::PluginHandle(_) => "PluginHandle",
|
||||
Value::Memory(_) => "Memory",
|
||||
Value::Resource(_) => "Resource",
|
||||
}
|
||||
}
|
||||
|
||||
@@ -200,6 +289,44 @@ impl Value {
|
||||
Value::Code(c) => format!("Code({:?}, {} bytes)", c.language, c.source.len()),
|
||||
Value::FunctionRef(r) => format!("FunctionRef({}::{})", r.module, r.name),
|
||||
Value::PluginHandle(h) => format!("PluginHandle({}::{})", h.plugin, h.export),
|
||||
// Never render the runtime handle: internal region identity is not
|
||||
// observable program data (RFC-CM-0001 §8).
|
||||
Value::Memory(_) => "Memory".to_string(),
|
||||
// Resource identity is host-private and never program data.
|
||||
Value::Resource(_) => "Resource".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether this value contains a live `Memory` handle anywhere.
|
||||
///
|
||||
/// Used at the host/plugin/foreign boundary, which must reject handles
|
||||
/// instead of serializing them.
|
||||
pub fn contains_memory(&self) -> bool {
|
||||
match self {
|
||||
Value::Memory(_) => true,
|
||||
Value::List(items) => items.iter().any(Value::contains_memory),
|
||||
Value::Map(entries) => entries.values().any(Value::contains_memory),
|
||||
Value::Table(table) => table
|
||||
.rows
|
||||
.iter()
|
||||
.flat_map(|row| row.iter())
|
||||
.any(Value::contains_memory),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
/// Whether this value contains a live `Resource` handle anywhere.
|
||||
pub fn contains_resource(&self) -> bool {
|
||||
match self {
|
||||
Value::Resource(_) => true,
|
||||
Value::List(items) => items.iter().any(Value::contains_resource),
|
||||
Value::Map(entries) => entries.values().any(Value::contains_resource),
|
||||
Value::Table(table) => table
|
||||
.rows
|
||||
.iter()
|
||||
.flat_map(|row| row.iter())
|
||||
.any(Value::contains_resource),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -325,6 +452,18 @@ mod tests {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn memory_display_never_leaks_the_runtime_handle() {
|
||||
let memory = Value::Memory(MemoryHandle::from_runtime(41, 7, 1));
|
||||
assert_eq!(memory.type_name(), "Memory");
|
||||
assert_eq!(memory.display(), "Memory");
|
||||
assert_eq!(memory.repr(), "Memory");
|
||||
assert!(!memory.display().contains("41"));
|
||||
assert!(!memory.repr().contains('7'));
|
||||
assert!(memory.contains_memory());
|
||||
assert!(Value::List(vec![memory]).contains_memory());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn big_integers_are_arbitrary_precision() {
|
||||
let big: BigInt = "123456789012345678901234567890".parse().unwrap();
|
||||
|
||||
@@ -145,6 +145,12 @@ fn encode(value: &Value) -> Json {
|
||||
"export": handle.export,
|
||||
"id": handle.id,
|
||||
}),
|
||||
// Active memory handles never cross the wire (RFC-CM-0001 §8).
|
||||
// The tag is emitted so an accidental transfer is visible instead of
|
||||
// silently becoming a number; decoding it is a hard error.
|
||||
Value::Memory(_) => json!({"type": "memory"}),
|
||||
// Resource handles are host-private; same non-transferable rule.
|
||||
Value::Resource(_) => json!({"type": "resource"}),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -321,6 +327,12 @@ fn decode(json: &Json, depth: usize, limits: &WireLimits) -> Result<Value, WireE
|
||||
.as_u64()
|
||||
.ok_or_else(|| WireError::Invalid("plugin_handle.id must be an integer".into()))?,
|
||||
})),
|
||||
"memory" => Err(WireError::Invalid(
|
||||
"Memory handles cannot cross the wire; copy bytes explicitly".into(),
|
||||
)),
|
||||
"resource" => Err(WireError::Invalid(
|
||||
"Resource handles cannot cross the wire".into(),
|
||||
)),
|
||||
other => Err(WireError::UnknownType(other.to_string())),
|
||||
}
|
||||
}
|
||||
@@ -393,6 +405,34 @@ mod tests {
|
||||
assert!(matches!(decoded, Value::Float(f) if f == f64::NEG_INFINITY));
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn memory_handles_are_not_transferable() {
|
||||
let value = Value::Memory(crate::MemoryHandle::from_runtime(1, 2, 1));
|
||||
let wire = to_wire(&value);
|
||||
assert_eq!(wire, json!({"type": "memory"}));
|
||||
assert_eq!(
|
||||
from_wire(&wire),
|
||||
Err(WireError::Invalid(
|
||||
"Memory handles cannot cross the wire; copy bytes explicitly".into()
|
||||
))
|
||||
);
|
||||
// A hand-written fake handle is rejected by the same tag rule.
|
||||
assert!(from_wire(&json!({"type": "memory", "region": 2})).is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn resource_handles_are_not_transferable() {
|
||||
let value = Value::Resource(crate::ResourceHandle::from_host(1, 2, 1));
|
||||
let wire = to_wire(&value);
|
||||
assert_eq!(wire, json!({"type": "resource"}));
|
||||
assert_eq!(
|
||||
from_wire(&wire),
|
||||
Err(WireError::Invalid(
|
||||
"Resource handles cannot cross the wire".into()
|
||||
))
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn untrusted_wire_is_validated() {
|
||||
assert_eq!(
|
||||
|
||||
Reference in new issue
Block a user