summaryrefslogtreecommitdiffstats
path: root/bytecode
diff options
context:
space:
mode:
Diffstat (limited to 'bytecode')
-rw-r--r--bytecode/src/encoding.rs44
-rw-r--r--bytecode/src/heap.rs7
-rw-r--r--bytecode/src/main.rs132
3 files changed, 156 insertions, 27 deletions
diff --git a/bytecode/src/encoding.rs b/bytecode/src/encoding.rs
index 80fcc58..92e6bf6 100644
--- a/bytecode/src/encoding.rs
+++ b/bytecode/src/encoding.rs
@@ -88,6 +88,28 @@ pub struct If {
}
#[derive(Debug, Clone, Copy)]
+pub struct Read {
+ pub out: u8,
+ pub ptr: u8,
+ pub off: Arg,
+ pub len: Arg,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct Write {
+ pub ptr: u8,
+ pub off: Arg,
+ pub len: Arg,
+}
+
+#[derive(Debug, Clone, Copy)]
+pub struct WriteErr {
+ pub ptr: u8,
+ pub off: Arg,
+ pub len: Arg,
+}
+
+#[derive(Debug, Clone, Copy)]
pub enum Op {
Alloc(Alloc),
Call,
@@ -102,6 +124,9 @@ pub enum Op {
Less(Less),
Eq(Eq),
If(If),
+ Read(Read),
+ Write(Write),
+ WriteErr(WriteErr),
}
struct Reader<'a> {
@@ -241,6 +266,25 @@ impl Op {
let target = usize::try_from(itarget)?;
Op::If(If { test, target })
}
+ 14 => {
+ let out = r.parse_local()?;
+ let ptr = r.parse_local()?;
+ let off = r.parse_arg(arg1_const)?;
+ let len = r.parse_arg(arg2_const)?;
+ Op::Read(Read { out, ptr, off, len })
+ }
+ 15 => {
+ let ptr = r.parse_local()?;
+ let off = r.parse_arg(arg1_const)?;
+ let len = r.parse_arg(arg2_const)?;
+ Op::Write(Write { ptr, off, len })
+ }
+ 16 => {
+ let ptr = r.parse_local()?;
+ let off = r.parse_arg(arg1_const)?;
+ let len = r.parse_arg(arg2_const)?;
+ Op::WriteErr(WriteErr { ptr, off, len })
+ }
_ => {
return Err(Box::from(format!("invalid code {}", code)));
}
diff --git a/bytecode/src/heap.rs b/bytecode/src/heap.rs
index 970db7d..f195613 100644
--- a/bytecode/src/heap.rs
+++ b/bytecode/src/heap.rs
@@ -132,11 +132,14 @@ impl Heap {
Ok(Value(self.buf[p]))
}
- pub fn poke(&mut self, p: usize, val: Value) -> Result<(), Box<dyn Error>> {
+ pub fn poke(&mut self, p: usize, off: usize, val: Value) -> Result<(), Box<dyn Error>> {
if p >= self.buf.len() {
return Err(Box::from("poke: out of range"));
}
- self.buf[p] = val.repr();
+ if off >= self.alloc_size(p) {
+ return Err(Box::from("poke: out of range"));
+ }
+ self.buf[p + off] = val.repr();
Ok(())
}
}
diff --git a/bytecode/src/main.rs b/bytecode/src/main.rs
index 4cba4ef..6ccd4b8 100644
--- a/bytecode/src/main.rs
+++ b/bytecode/src/main.rs
@@ -6,26 +6,69 @@ use encoding::{Arg, Op};
use heap::Heap;
use std::error::Error;
use std::ffi::OsString;
-use std::io::{stderr, Write};
+use std::io::{stdin, BufWriter, Read, Write};
use value::Value;
-struct State {
- i: usize,
- heap: Heap,
+trait ReadArg {
+ fn read_arg(&self, a: Arg) -> Value;
}
-impl State {
+impl ReadArg for Heap {
fn read_arg(&self, a: Arg) -> Value {
match a {
- Arg::Local(l) => self.heap.locals[usize::from(l)],
+ Arg::Local(l) => self.locals[usize::from(l)],
Arg::Const(c) => c,
}
}
+}
+
+fn write(
+ w: &mut impl Write,
+ heap: &Heap,
+ ptr: u8,
+ off: Arg,
+ len: Arg,
+) -> Result<(), Box<dyn Error>> {
+ let Some(ptr) = heap.locals[usize::from(ptr)].to_pointer() else {
+ return Err(Box::from("write needs a pointer"));
+ };
+ let Some(ioff) = heap.read_arg(off).to_int() else {
+ return Err(Box::from("write needs an int"));
+ };
+ let Ok(off) = usize::try_from(ioff) else {
+ return Err(Box::from("write: off is negative"));
+ };
+ let Some(ilen) = heap.read_arg(len).to_int() else {
+ return Err(Box::from("write needs an int"));
+ };
+ let Ok(len) = usize::try_from(ilen) else {
+ return Err(Box::from("write: len is negative"));
+ };
+ for i in 0..len {
+ let Some(ibyte) = heap.peek(ptr + off + i)?.to_int() else {
+ return Err(Box::from("write: buffer has non-integer entries"));
+ };
+ let Ok(byte) = u8::try_from(ibyte) else {
+ return Err(Box::from("write: buffer entry is not between 0 and 255"));
+ };
+ w.write_all(&[byte])?;
+ }
+ w.flush()?;
+ Ok(())
+}
+
+struct State {
+ i: usize,
+ heap: Heap,
+ stdout: BufWriter<Box<dyn Write>>,
+ stderr: BufWriter<Box<dyn Write>>,
+}
+impl State {
fn op(&mut self, op: Op) -> Result<(), Box<dyn Error>> {
match op {
Op::Alloc(op) => {
- let Some(i) = self.read_arg(op.size).to_int() else {
+ let Some(i) = self.heap.read_arg(op.size).to_int() else {
return Err(Box::from("alloc needs an int"));
};
self.heap.locals[usize::from(op.out)] = Value::from_pointer(self.heap.alloc(i)?);
@@ -40,55 +83,55 @@ impl State {
let Some(p) = self.heap.locals[usize::from(op.ptr)].to_pointer() else {
return Err(Box::from("poke needs a pointer"));
};
- self.heap.poke(p + op.offset, self.read_arg(op.val))?;
+ self.heap.poke(p, op.offset, self.heap.read_arg(op.val))?;
}
Op::Peek(op) => {
- let Some(p) = self.read_arg(op.val).to_pointer() else {
+ let Some(p) = self.heap.read_arg(op.val).to_pointer() else {
return Err(Box::from("peek needs a pointer"));
};
self.heap.locals[usize::from(op.out)] = self.heap.peek(p + op.offset)?;
}
Op::Shuf(op) => {
- self.heap.locals[usize::from(op.out)] = self.read_arg(op.val);
+ self.heap.locals[usize::from(op.out)] = self.heap.read_arg(op.val);
}
Op::Exit(op) => {
- let Some(i) = self.read_arg(op.val).to_int() else {
+ let Some(i) = self.heap.read_arg(op.val).to_int() else {
std::process::exit(255);
};
std::process::exit(i as i32);
}
Op::Add(op) => {
- let Some(v1) = self.read_arg(op.val1).to_int() else {
+ let Some(v1) = self.heap.read_arg(op.val1).to_int() else {
return Err(Box::from("add needs an int"));
};
- let Some(v2) = self.read_arg(op.val2).to_int() else {
+ let Some(v2) = self.heap.read_arg(op.val2).to_int() else {
return Err(Box::from("add needs an int"));
};
self.heap.locals[usize::from(op.out)] = Value::from_int(v1.wrapping_add(v2));
}
Op::Sub(op) => {
- let Some(v1) = self.read_arg(op.val1).to_int() else {
+ let Some(v1) = self.heap.read_arg(op.val1).to_int() else {
return Err(Box::from("sub needs an int"));
};
- let Some(v2) = self.read_arg(op.val2).to_int() else {
+ let Some(v2) = self.heap.read_arg(op.val2).to_int() else {
return Err(Box::from("sub needs an int"));
};
self.heap.locals[usize::from(op.out)] = Value::from_int(v1.wrapping_sub(v2));
}
Op::Mul(op) => {
- let Some(v1) = self.read_arg(op.val1).to_int() else {
+ let Some(v1) = self.heap.read_arg(op.val1).to_int() else {
return Err(Box::from("mul needs an int"));
};
- let Some(v2) = self.read_arg(op.val2).to_int() else {
+ let Some(v2) = self.heap.read_arg(op.val2).to_int() else {
return Err(Box::from("mul needs an int"));
};
self.heap.locals[usize::from(op.out)] = Value::from_int(v1.wrapping_mul(v2));
}
Op::Div(op) => {
- let Some(v1) = self.read_arg(op.val1).to_int() else {
+ let Some(v1) = self.heap.read_arg(op.val1).to_int() else {
return Err(Box::from("div needs an int"));
};
- let Some(v2) = self.read_arg(op.val2).to_int() else {
+ let Some(v2) = self.heap.read_arg(op.val2).to_int() else {
return Err(Box::from("div needs an int"));
};
let Some(res) = v1.checked_div(v2) else {
@@ -97,33 +140,70 @@ impl State {
self.heap.locals[usize::from(op.out)] = Value::from_int(res);
}
Op::Less(op) => {
- let Some(v1) = self.read_arg(op.val1).to_int() else {
+ let Some(v1) = self.heap.read_arg(op.val1).to_int() else {
return Err(Box::from("less needs an int"));
};
- let Some(v2) = self.read_arg(op.val2).to_int() else {
+ let Some(v2) = self.heap.read_arg(op.val2).to_int() else {
return Err(Box::from("less needs an int"));
};
let res = if v1 < v2 { 1 } else { 0 };
self.heap.locals[usize::from(op.out)] = Value::from_int(res);
}
Op::Eq(op) => {
- let Some(v1) = self.read_arg(op.val1).to_int() else {
+ let Some(v1) = self.heap.read_arg(op.val1).to_int() else {
return Err(Box::from("eq needs an int"));
};
- let Some(v2) = self.read_arg(op.val2).to_int() else {
+ let Some(v2) = self.heap.read_arg(op.val2).to_int() else {
return Err(Box::from("eq needs an int"));
};
let res = if v1 == v2 { 1 } else { 0 };
self.heap.locals[usize::from(op.out)] = Value::from_int(res);
}
Op::If(op) => {
- let Some(t) = self.read_arg(op.test).to_int() else {
+ let Some(t) = self.heap.read_arg(op.test).to_int() else {
return Err(Box::from("if needs an int"));
};
if t != 0 {
self.i = op.target;
}
}
+ Op::Read(op) => {
+ let Some(ptr) = self.heap.locals[usize::from(op.ptr)].to_pointer() else {
+ return Err(Box::from("read needs a pointer"));
+ };
+ let Some(ioff) = self.heap.read_arg(op.off).to_int() else {
+ return Err(Box::from("read needs an int"));
+ };
+ let Ok(off) = usize::try_from(ioff) else {
+ return Err(Box::from("read: off is negative"));
+ };
+ let Some(ilen) = self.heap.read_arg(op.len).to_int() else {
+ return Err(Box::from("read needs an int"));
+ };
+ let Ok(len) = usize::try_from(ilen) else {
+ return Err(Box::from("read: len is negative"));
+ };
+ let mut n = 0;
+ for byte in stdin().lock().bytes().take(len) {
+ let byte = byte?;
+ self.heap
+ .poke(ptr, off + n, Value::from_int(i64::from(byte)))?;
+ n += 1;
+ if byte == b'\n' {
+ break;
+ }
+ }
+ self.heap.locals[usize::from(op.out)] = Value::from_int(
+ i64::try_from(n)
+ .expect("we can never read more than len bytes, and len fit in an i64"),
+ );
+ }
+ Op::Write(op) => {
+ write(&mut self.stdout, &self.heap, op.ptr, op.off, op.len)?;
+ }
+ Op::WriteErr(op) => {
+ write(&mut self.stderr, &self.heap, op.ptr, op.off, op.len)?;
+ }
}
Ok(())
}
@@ -138,6 +218,8 @@ fn run() -> Result<(), Box<dyn Error>> {
let mut st = State {
i: 0,
heap: Heap::new(),
+ stdout: BufWriter::new(Box::new(std::io::stdout().lock())),
+ stderr: BufWriter::new(Box::new(std::io::stderr().lock())),
};
loop {
let (n, op) = Op::parse(&prog[st.i..])?;
@@ -148,7 +230,7 @@ fn run() -> Result<(), Box<dyn Error>> {
fn main() {
if let Err(err) = run() {
- let _ = writeln!(stderr(), "FAIL: {}", err);
+ let _ = writeln!(std::io::stderr(), "FAIL: {}", err);
std::process::exit(255);
}
}
generated by cgit v1.3.1 (git 2.54.0) at 2026-09-04 02:27:46 +0000