Add strings and IO.

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);
     }
 }