Start implementing function calls.

Author: progval

src/lib.rs

@@ -22,19 +22,20 @@ impl fmt::Display for InterpreterError {
     }
 }
 
-pub fn run_module<R: io::Read>(reader: &mut R) -> Result<(), InterpreterError> {
+pub fn run_module<R: io::Read, EP: sandbox::EnvProxy>(reader: &mut R, envproxy: &mut EP) -> Result<(), InterpreterError> {
     let mut buf = [0; 12];
     try!(reader.read_exact(&mut buf).map_err(InterpreterError::Io));
     // 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));
-    let mut envproxy = sandbox::MockEnvProxy::new();
-    processor::run_code_object(&mut envproxy, module, &mut store);
+    processor::run_code_object(envproxy, &mut store, module);
     Ok(())
 }
 
 #[test]
 fn test_hello_world() {
     let mut reader: &[u8] = b"\xee\x0c\r\n\x15j\nW\x15\x00\x00\x00\xe3\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x02\x00\x00\x00@\x00\x00\x00s\x0e\x00\x00\x00e\x00\x00d\x00\x00\x83\x01\x00\x01d\x01\x00S)\x02z\x0bHello worldN)\x01\xda\x05print\xa9\x00r\x02\x00\x00\x00r\x02\x00\x00\x00\xfa\x0b/tmp/foo.py\xda\x08<module>\x01\x00\x00\x00s\x00\x00\x00\x00";
-    run_module(&mut reader);
+    let mut envproxy = sandbox::MockEnvProxy::new();
+    run_module(&mut reader, &mut envproxy).unwrap();
+    assert_eq!(*envproxy.stdout_content.lock().unwrap(), b"Hello world\n");
 }

src/processor/instructions.rs

@@ -8,7 +8,7 @@ pub enum Instruction {
     LoadConst(usize),
     LoadName(usize),
     LoadFast(u16),
-    CallFunction(u8, u8),
+    CallFunction(usize, usize), // nb_args, nb_kwargs
 }
 
 #[derive(Debug)]
@@ -49,7 +49,7 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
                 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()),
+                131 => Instruction::CallFunction(self.read_byte() as usize, self.read_byte() as usize),
                 _ => panic!(format!("Opcode not supported: {}", opcode)),
             }
         })

src/processor/mod.rs

@@ -16,7 +16,15 @@ pub enum ProcessorError {
     InvalidNameIndex,
 }
 
-fn run_code<EP: EnvProxy>(envproxy: &mut EP, code: Code, store: &mut ObjectStore) -> Result<ObjectRef, ProcessorError> {
+fn call_function<EP: EnvProxy>(envproxy: &mut EP, store: &mut ObjectStore, func_ref: &ObjectRef, args: Vec<ObjectRef>, kwags: Vec<ObjectRef>) -> Result<ObjectRef, ProcessorError> {
+    let code = match store.deref(func_ref).content {
+        ObjectContent::Code(ref code) => code.clone(),
+        _ => return Err(ProcessorError::NotACodeObject),
+    };
+    run_code(envproxy, store, code)
+}
+
+fn run_code<EP: EnvProxy>(envproxy: &mut EP, store: &mut ObjectStore, code: Code) -> 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;
@@ -28,16 +36,25 @@ fn run_code<EP: EnvProxy>(envproxy: &mut EP, code: Code, store: &mut ObjectStore
             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()),
+            Instruction::CallFunction(nb_args, nb_kwargs) => {
+                // See “Call constructs” at:
+                // http://security.coverity.com/blog/2014/Nov/understanding-python-bytecode.html
+                let kwargs = try!(stack.pop_many(nb_kwargs*2).ok_or(ProcessorError::StackTooSmall));
+                let args = try!(stack.pop_many(nb_args).ok_or(ProcessorError::StackTooSmall));
+                let func = try!(stack.pop().ok_or(ProcessorError::StackTooSmall));
+                let ret_value = call_function(envproxy, store, &func, args, kwargs);
+                stack.push(try!(ret_value))
+            }
             _ => 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> {
+pub fn run_code_object<EP: EnvProxy>(envproxy: &mut EP, store: &mut ObjectStore, module: ObjectRef) -> 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)
+    run_code(envproxy, store, code)
 }

src/sandbox/mod.rs

@@ -28,7 +28,7 @@ impl EnvProxy for RealEnvProxy {
 
 
 
-struct VectorWriter {
+pub struct VectorWriter {
     vector: Arc<Mutex<Vec<u8>>>,
 }
 
@@ -49,7 +49,7 @@ impl io::Write for VectorWriter {
 }
 
 pub struct MockEnvProxy {
-    stdout_content: Arc<Mutex<Vec<u8>>>,
+    pub stdout_content: Arc<Mutex<Vec<u8>>>,
 }
 
 impl MockEnvProxy {

src/stack.rs

@@ -3,6 +3,7 @@ pub trait Stack {
 
     fn top(&self) -> Option<&Self::Item>;
     fn pop(&mut self) -> Option<Self::Item>;
+    fn pop_many(&mut self, count: usize) -> Option<Vec<Self::Item>>;
     fn push(&mut self, value: Self::Item);
 }
 
@@ -27,6 +28,16 @@ impl<Item> Stack for VectorStack<Item> {
         self.vector.pop()
     }
 
+    fn pop_many(&mut self, count: usize) -> Option<Vec<Self::Item>> {
+        if count > self.vector.len() {
+            None
+        }
+        else {
+            let length = self.vector.len();
+            Some(self.vector.drain((length-count)..length).into_iter().collect())
+        }
+    }
+
     fn push(&mut self, value: Self::Item) {
         self.vector.push(value)
     }