Add strings and IO.

8 files changed, 201 insertions, 31 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);
     }
 }
diff --git a/codegen.sml b/codegen.sml
index 9dbee51..67b2d30 100644
--- a/codegen.sml
+++ b/codegen.sml
@@ -169,6 +169,12 @@ struct
               @ Syntax.OLabel trueLabel
               :: go k1
             end
+        | Syntax.CPrimop (Syntax.PRead, [Syntax.VVar ptr, off, len], [res], [k]) =>
+            Syntax.ORead (translate res, translate ptr, translateVal off, translateVal len) :: go k
+        | Syntax.CPrimop (Syntax.PWrite, [Syntax.VVar ptr, off, len], _, [k]) =>
+            Syntax.OWrite (translate ptr, translateVal off, translateVal len) :: go k
+        | Syntax.CPrimop (Syntax.PWriteErr, [Syntax.VVar ptr, off, len], _, [k]) =>
+            Syntax.OWriteErr (translate ptr, translateVal off, translateVal len) :: go k
         | _ => raise Fail ("malformed CPS:\n" ^ Syntax.cexpToString expr)
     in go expr
     end
diff --git a/cps.sml b/cps.sml
index 83d07f7..2d9d85d 100644
--- a/cps.sml
+++ b/cps.sml
@@ -45,7 +45,14 @@ struct
                Syntax.CApp (f', [x', Syntax.VVar addr]))))
         end
     | Syntax.LInt i => cont (Syntax.VInt i)
-    | Syntax.LString s => cont (Syntax.VString s)
+    | Syntax.LString s =>
+        let val temp = Gensym.new ()
+        in
+          Syntax.CRecord
+            ( [(map (fn c => (Syntax.VInt (Char.ord c), [])) (String.explode s), temp)]
+            , cont (Syntax.VVar temp)
+            )
+        end
     | Syntax.LRecord [] => cont (Syntax.VInt 0)
     | Syntax.LSelect (i, expr) =>
         let val temp = Gensym.new ()
diff --git a/elab.sml b/elab.sml
index 2895894..a99758a 100644
--- a/elab.sml
+++ b/elab.sml
@@ -10,6 +10,9 @@ struct
     | "sub" => Syntax.PSub
     | "mul" => Syntax.PMul
     | "div" => Syntax.PDiv
+    | "read" => Syntax.PRead
+    | "write" => Syntax.PWrite
+    | "writeErr" => Syntax.PWriteErr
     | _ => raise Fail ("invalid op: " ^ s)
 
   fun enumerate (l : 'a list) : (int * 'a) list =
diff --git a/linker.sml b/linker.sml
index d576c24..684451d 100644
--- a/linker.sml
+++ b/linker.sml
@@ -47,7 +47,6 @@ struct
       fun writeValue w (Syntax.VVar v) = writeVar w v
         | writeValue w (Syntax.VLabel l) = writeInt w (getOpt (IntMap.lookup l m, 0))
         | writeValue w (Syntax.VInt i) = writeInt w i
-        | writeValue w (Syntax.VString _) = raise Fail "I don't support strings yet"
     in
       case oper of
         Syntax.OAlloc (r, v) =>
@@ -108,6 +107,22 @@ struct
           writeValue w condition ;
           writeValue w (Syntax.VLabel label))
       | Syntax.OLabel _ => ()
+      | Syntax.ORead (r, ptr, off, len) =>
+          (makeOpcode w 14 (isConst off) (isConst len) ;
+          writeVar w r ;
+          writeVar w ptr ;
+          writeValue w off ;
+          writeValue w len)
+      | Syntax.OWrite (ptr, off, len) =>
+          (makeOpcode w 15 (isConst off) (isConst len) ;
+          writeVar w ptr ;
+          writeValue w off ;
+          writeValue w len)
+      | Syntax.OWriteErr (ptr, off, len) =>
+          (makeOpcode w 16 (isConst off) (isConst len) ;
+          writeVar w ptr ;
+          writeValue w off ;
+          writeValue w len)
     end
 
   fun link (program : Syntax.opcode list) : Word8Vector.vector =
diff --git a/syntax.sml b/syntax.sml
index 5672a5b..e05beee 100644
--- a/syntax.sml
+++ b/syntax.sml
@@ -47,6 +47,9 @@ struct
   | PLess
   | PEq
   | PIf
+  | PRead
+  | PWrite
+  | PWriteErr
 
   datatype lexp =
     LVar of var
@@ -65,7 +68,6 @@ struct
     VVar of var
   | VLabel of var
   | VInt of int
-  | VString of string
 
   datatype cexp =
     CRecord of ((value * int list) list * var) list * cexp
@@ -89,6 +91,9 @@ struct
   | OEq of var * value * value
   | OIf of value * var
   | OLabel of var
+  | ORead of var * var * value * value
+  | OWrite of var * value * value
+  | OWriteErr of var * value * value
 
   fun listToString (show : 'a -> string) (l : 'a list) =
     "[" ^ String.concatWith ", " (map show l) ^ "]"
@@ -163,6 +168,9 @@ struct
     | PLess => "PLess"
     | PEq => "PEq"
     | PIf => "PIf"
+    | PRead => "PRead"
+    | PWrite => "PWrite"
+    | PWriteErr => "PWriteErr"
 
   fun lexpToStringI (indent : string) (x : lexp) : string =
     case x of
@@ -184,7 +192,6 @@ struct
       VVar v => "VVar " ^ Int.toString v
     | VLabel l => "VLabel " ^ Int.toString l
     | VInt i => "VInt " ^ Int.toString i
-    | VString s => "VString " ^ quote s
 
   fun cexpToStringI (indent : string) (x : cexp) : string =
     let
@@ -216,4 +223,7 @@ struct
     | OEq (r, v1, v2) => "Var " ^ Int.toString r ^ " = OEq (" ^ valueToString v1 ^ ", " ^ valueToString v2 ^ ")"
     | OIf (condition, target) => "OIf (" ^ valueToString condition ^ ") goto " ^ Int.toString target
     | OLabel l => "OLabel " ^ Int.toString l
+    | ORead (r, ptr, off, len) => "Var " ^ Int.toString r ^ " = ORead (Var " ^ Int.toString ptr ^ ", " ^ valueToString off ^ ", " ^ valueToString len ^ ")"
+    | OWrite (ptr, off, len) => "OWrite (Var " ^ Int.toString ptr ^ ", " ^ valueToString off ^ ", " ^ valueToString len ^ ")"
+    | OWriteErr (ptr, off, len) => "OWriteErr (Var " ^ Int.toString ptr ^ ", " ^ valueToString off ^ ", " ^ valueToString len ^ ")"
 end