Start writing processor. Add stack and basic sandbox.

Author: progval

src/lib.rs

@@ -1,6 +1,8 @@
 mod marshal;
 mod objects;
-//mod processor;
+mod processor;
+mod sandbox;
+mod stack;
 
 use std::fmt;
 use std::io;
@@ -26,7 +28,8 @@ pub fn run_module<R: io::Read>(reader: &mut R) -> Result<(), InterpreterError> {
     // TODO: do something with the content of the buffer
     let mut store = objects::ObjectStore::new();
     let module = try!(marshal::read_object(reader, &mut store).map_err(InterpreterError::Unmarshal));
-    //processor::run_code_object(module, &mut references);
+    let mut envproxy = sandbox::MockEnvProxy::new();
+    processor::run_code_object(&mut envproxy, module, &mut store);
     Ok(())
 }
 

src/marshal/mod.rs

@@ -5,41 +5,68 @@ use std::io;
 use std::collections::HashSet;
 use super::objects::{Code, ObjectContent, Object, ObjectRef, ObjectStore};
 use self::common::Object as MarshalObject;
+use self::common::Code as MarshalCode;
 
 macro_rules! translate_vector {
     ( $e:expr, $map:ident, $store:ident ) => { $e.into_iter().map(|o| translate_object(o, $map, $store)).collect() }
 }
 
-fn translate_object(marshal_object: MarshalObject, translation_map: &Vec<ObjectRef>, store: &mut ObjectStore) -> ObjectRef {
+macro_rules! translate_code_field {
+    ( $code:ident, $expected:ident, $field:ident, $map:ident, $store:ident, $error:expr ) => {
+        match translate_object_content($code.$field, $map, $store) {
+            ObjectContent::$expected(v) => v,
+            _ => panic!($error),
+        }
+    };
+}
+
+// TODO: more fields
+fn translate_code(c: MarshalCode, translation_map: &Vec<ObjectRef>, store: &mut ObjectStore) -> Code {
+    let code = translate_code_field!(c, Bytes, code, translation_map, store, "Code.code object must be bytes.");
+    let consts = translate_code_field!(c, Tuple, consts, translation_map, store, "Code.consts object must be a tuple.");
+    let names = translate_code_field!(c, Tuple, names, translation_map, store, "Code.names object must be a tuple.");
+    Code { code: code, consts: consts, names: names }
+}
+
+fn translate_object_content(marshal_object: MarshalObject, translation_map: &Vec<ObjectRef>, store: &mut ObjectStore) -> ObjectContent {
     match marshal_object {
         MarshalObject::Hole => panic!("Remaining hole."),
-        MarshalObject::None => store.allocate(ObjectContent::None),
-        MarshalObject::False => store.allocate(ObjectContent::False),
-        MarshalObject::True => store.allocate(ObjectContent::True),
-        MarshalObject::Int(i) => store.allocate(ObjectContent::Int(i)),
-        MarshalObject::String(s) => store.allocate(ObjectContent::String(s)),
-        MarshalObject::Bytes(v) => store.allocate(ObjectContent::Bytes(v)),
+        MarshalObject::None => ObjectContent::None,
+        MarshalObject::False => ObjectContent::False,
+        MarshalObject::True => ObjectContent::True,
+        MarshalObject::Int(i) => ObjectContent::Int(i),
+        MarshalObject::String(s) => ObjectContent::String(s),
+        MarshalObject::Bytes(v) => ObjectContent::Bytes(v),
         MarshalObject::Tuple(v) => {
             let v = translate_vector!(v, translation_map, store);
-            store.allocate(ObjectContent::Tuple(v))
+            ObjectContent::Tuple(v)
         },
         MarshalObject::List(v) => {
             let v = translate_vector!(v, translation_map, store);
-            store.allocate(ObjectContent::List(v))
+            ObjectContent::List(v)
         },
         MarshalObject::Set(v) => {
             let v = translate_vector!(v, translation_map, store);
-            store.allocate(ObjectContent::Set(v))
+            ObjectContent::Set(v)
         },
         MarshalObject::FrozenSet(v) => {
             let v = translate_vector!(v, translation_map, store);
-            store.allocate(ObjectContent::FrozenSet(v))
+            ObjectContent::FrozenSet(v)
         },
         MarshalObject::Code(c) => {
-            let code = translate_object(c.code, translation_map, store);
-            store.allocate(ObjectContent::Code(Code { code: code})) // TODO: more fields
+            ObjectContent::Code(translate_code(*c, translation_map, store))
         },
+        MarshalObject::Ref(_) => panic!("For references, call translate_and_allocate_object.")
+    }
+}
+
+fn translate_object(marshal_object: MarshalObject, translation_map: &Vec<ObjectRef>, store: &mut ObjectStore) -> ObjectRef {
+    match marshal_object {
         MarshalObject::Ref(i) => translation_map.get(i as usize).unwrap().clone(), // TODO: overflow check
+        _ => {
+            let obj_content = translate_object_content(marshal_object, translation_map, store);
+            store.allocate(obj_content)
+        },
     }
 }
 

src/objects/mod.rs

@@ -1,14 +1,16 @@
+use std::collections::HashSet;
 
 #[derive(Debug)]
+#[derive(Clone)]
 pub struct Code {/*
     pub argcount: u32,
     pub kwonlyargcount: u32,
     pub nlocals: u32,
     pub stacksize: u32,
     pub flags: u32,*/
-    pub code: ObjectRef,/*
-    pub consts: Object,
-    pub names: Object,
+    pub code: Vec<u8>,
+    pub consts: Vec<ObjectRef>,
+    pub names: Vec<ObjectRef>,/*
     pub varnames: Object,
     pub freevars: Object,
     pub cellvars: Object,
@@ -35,7 +37,7 @@ pub enum ObjectContent {
 
 #[derive(Debug)]
 pub struct Object {
-    content: ObjectContent,
+    pub content: ObjectContent,
 }
 
 #[derive(Debug)]
@@ -59,4 +61,9 @@ impl ObjectStore {
         self.all_objects.push(Object { content: obj });
         obj_ref
     }
+
+    pub fn deref(&self, obj_ref: &ObjectRef) -> &Object {
+        // TODO: check the reference is valid
+        self.all_objects.get(obj_ref.index).unwrap()
+    }
 }

src/processor/instructions.rs

@@ -3,8 +3,12 @@ use std::str::Bytes;
 #[derive(PartialEq)]
 #[derive(Debug)]
 pub enum Instruction {
+    PopTop,
     ReturnValue,
+    LoadConst(usize),
+    LoadName(usize),
     LoadFast(u16),
+    CallFunction(u16),
 }
 
 #[derive(Debug)]
@@ -19,6 +23,13 @@ impl<I> InstructionDecoder<I> where I: Iterator {
 }
 
 impl<'a, I> InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
+    fn read_byte(&mut self) -> u8 {
+        match (self.bytestream.next(), self.bytestream.next()) {
+            (Some(b1), Some(b2)) => {
+                ((*b2 as u16) << 8) + (*b1 as u16)},
+            _ => panic!("End of stream in the middle of an instruction."),
+        }
+    }
     fn read_argument(&mut self) -> u16 {
         match (self.bytestream.next(), self.bytestream.next()) {
             (Some(b1), Some(b2)) => {
@@ -34,8 +45,12 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
     fn next(&mut self) -> Option<Instruction> {
         self.bytestream.next().map(|opcode| {
             match *opcode {
+                1 => Instruction::PopTop,
                 83 => Instruction::ReturnValue,
+                100 => Instruction::LoadConst(self.read_argument() as usize),
+                101 => Instruction::LoadName(self.read_argument() as usize),
                 124 => Instruction::LoadFast(self.read_argument()),
+                131 => Instruction::CallFunction(self.read_byte(), self.read_byte()),
                 _ => panic!(format!("Opcode not supported: {}", opcode)),
             }
         })

src/processor/mod.rs

@@ -1 +1,43 @@
 pub mod instructions;
+
+use super::objects::{Object, Code, ObjectStore, ObjectRef, ObjectContent};
+use super::sandbox::EnvProxy;
+use super::stack::{Stack, VectorStack};
+use self::instructions::Instruction;
+
+pub enum ProcessorError {
+    CircularReference,
+    InvalidReference,
+    NotACodeObject,
+    CodeObjectIsNotBytes,
+    InvalidProgramCounter,
+    StackTooSmall,
+    InvalidConstIndex,
+    InvalidNameIndex,
+}
+
+fn run_code<EP: EnvProxy>(envproxy: &mut EP, code: Code, store: &mut ObjectStore) -> Result<ObjectRef, ProcessorError> {
+    let bytecode: Vec<u8> = code.code;
+    let instructions: Vec<Instruction> = instructions::InstructionDecoder::new(bytecode.iter()).into_iter().collect();
+    let mut program_counter = 0 as usize;
+    let mut stack = VectorStack::new();
+    while true {
+        let instruction = try!(instructions.get(program_counter).ok_or(ProcessorError::InvalidProgramCounter));
+        program_counter += 1;
+        match *instruction {
+            Instruction::ReturnValue => return Ok(try!(stack.pop().ok_or(ProcessorError::StackTooSmall))),
+            Instruction::LoadConst(i) => stack.push(try!(code.names.get(i).ok_or(ProcessorError::InvalidConstIndex)).clone()),
+            Instruction::LoadName(i) => stack.push(try!(code.names.get(i).ok_or(ProcessorError::InvalidNameIndex)).clone()),
+            _ => panic!(format!("todo: instruction {:?}", *instruction)),
+        }
+    };
+    panic!("Unreachable")
+}
+
+pub fn run_code_object<EP: EnvProxy>(envproxy: &mut EP, module: ObjectRef, store: &mut ObjectStore) -> Result<ObjectRef, ProcessorError> {
+    let code = match store.deref(&module).content {
+        ObjectContent::Code(ref code) => code.clone(),
+        _ => return Err(ProcessorError::NotACodeObject),
+    };
+    run_code(envproxy, code, store)
+}

src/sandbox/mod.rs

@@ -0,0 +1,67 @@
+use std::io;
+use std::sync::{Arc, Mutex};
+
+/// Real environment (I/O, signals, …) or a mock
+pub trait EnvProxy {
+    type Stdout: io::Write;
+    fn stdout(&self) -> Self::Stdout;
+}
+
+
+
+/// An EnvProxy that exposes the real environment
+pub struct RealEnvProxy {
+}
+
+impl RealEnvProxy {
+    pub fn new() -> RealEnvProxy {
+        RealEnvProxy { }
+    }
+}
+
+impl EnvProxy for RealEnvProxy {
+    type Stdout = io::Stdout;
+    fn stdout(&self) -> Self::Stdout {
+        io::stdout()
+    }
+}
+
+
+
+struct VectorWriter {
+    vector: Arc<Mutex<Vec<u8>>>,
+}
+
+impl VectorWriter {
+    pub fn new(vector: Arc<Mutex<Vec<u8>>>) -> VectorWriter {
+        VectorWriter { vector: vector }
+    }
+}
+
+impl io::Write for VectorWriter {
+    fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
+        self.vector.lock().unwrap().extend(buf); // TODO: remove unwrap()
+        Ok(buf.len())
+    }
+    fn flush(&mut self) -> io::Result<()> {
+        Ok(())
+    }
+}
+
+pub struct MockEnvProxy {
+    stdout_content: Arc<Mutex<Vec<u8>>>,
+}
+
+impl MockEnvProxy {
+    pub fn new() -> MockEnvProxy {
+        MockEnvProxy { stdout_content: Arc::new(Mutex::new(vec![])) }
+    }
+}
+
+
+impl EnvProxy for MockEnvProxy {
+    type Stdout = VectorWriter;
+    fn stdout(&self) -> Self::Stdout {
+        VectorWriter::new(self.stdout_content.clone())
+    }
+}

src/stack.rs

@@ -0,0 +1,33 @@
+pub trait Stack {
+    type Item;
+
+    fn top(&self) -> Option<&Self::Item>;
+    fn pop(&mut self) -> Option<Self::Item>;
+    fn push(&mut self, value: Self::Item);
+}
+
+pub struct VectorStack<Item: Sized> {
+    vector: Vec<Item>
+}
+
+impl<Item> VectorStack<Item> {
+    pub fn new() -> VectorStack<Item> {
+        VectorStack { vector: Vec::new() }
+    }
+}
+
+impl<Item> Stack for VectorStack<Item> {
+    type Item = Item;
+
+    fn top(&self) -> Option<&Self::Item> {
+        self.vector.last()
+    }
+
+    fn pop(&mut self) -> Option<Self::Item> {
+        self.vector.pop()
+    }
+
+    fn push(&mut self, value: Self::Item) {
+        self.vector.push(value)
+    }
+}