Add compilation of lambdas and support function arguments.

cthulahoops · cthulahoops · commit b917efa8a86f · 2018-07-28T11:57:41.000+01:00
diff --git a/vm/src/bytecode.rs b/vm/src/bytecode.rs
@@ -17,13 +17,15 @@ use std::fmt;
 pub struct CodeObject {
     pub instructions: Vec<Instruction>,
     pub label_map: HashMap<Label, usize>,
+    pub arg_names: Vec<String>,
 }
 
 impl CodeObject {
-    pub fn new() -> CodeObject {
+    pub fn new(arg_names : Vec<String>) -> CodeObject {
         CodeObject {
             instructions: Vec::new(),
             label_map: HashMap::new(),
+            arg_names: arg_names,
         }
     }
 }
diff --git a/vm/src/compile.rs b/vm/src/compile.rs
@@ -15,7 +15,7 @@ struct Compiler {
 
 pub fn compile(rt: &mut Executor, source: &String, mode: Mode) -> Result<PyObjectRef, String> {
     let mut compiler = Compiler::new();
-    compiler.push_code_object(CodeObject::new());
+    compiler.push_code_object(CodeObject::new(Vec::new()));
     match mode {
         Mode::Exec => match parser::parse_program(source) {
             Ok(ast) => {
@@ -62,7 +62,7 @@ impl Compiler {
     }
 
     fn push_code_object(&mut self, code_object: CodeObject) {
-        self.code_object_stack.push(CodeObject::new());
+        self.code_object_stack.push(CodeObject::new(Vec::new()));
     }
 
     fn pop_code_object(&mut self) -> CodeObject {
@@ -191,7 +191,7 @@ impl Compiler {
             }
             ast::Statement::FunctionDef { name, args, body } => {
                 // Create bytecode for this function:
-                self.code_object_stack.push(CodeObject::new());
+                self.code_object_stack.push(CodeObject::new(args.to_vec()));
                 self.compile_statements(body);
                 let code = self.code_object_stack.pop().unwrap();
                 self.emit(Instruction::LoadConst {
@@ -444,6 +444,22 @@ impl Compiler {
                     name: name.to_string(),
                 });
             }
+            ast::Expression::Lambda { args, body } => {
+                self.code_object_stack.push(CodeObject::new(args.to_vec()));
+                self.compile_expression(body);
+                self.emit(Instruction::ReturnValue);
+                let code = self.code_object_stack.pop().unwrap();
+                self.emit(Instruction::LoadConst {
+                    value: bytecode::Constant::Code { code: code },
+                });
+                self.emit(Instruction::LoadConst {
+                    value: bytecode::Constant::String {
+                        value: String::from("<lambda>"),
+                    },
+                });
+                // Turn code object into function object:
+                self.emit(Instruction::MakeFunction);
+            }
         }
     }
 
diff --git a/vm/src/vm.rs b/vm/src/vm.rs
@@ -10,7 +10,7 @@ use std::ops::Deref;
 
 use super::builtins;
 use super::bytecode;
-use super::frame::{Block, Frame};
+use super::frame::{Block, Frame, copy_code};
 use super::import::import;
 use super::objlist;
 use super::objstr;
@@ -431,7 +431,12 @@ impl VirtualMachine {
         match f.kind {
             PyObjectKind::RustFunction { ref function } => f.call(self, args),
             PyObjectKind::Function { ref code } => {
-                let frame = Frame::new(code.clone(), HashMap::new(), self.new_dict());
+                let mut locals = self.new_dict();
+                let code_object = copy_code(code.clone());
+                for (name, value) in code_object.arg_names.iter().zip(args) {
+                    locals.set_item(name, value);
+                }
+                let frame = Frame::new(code.clone(), HashMap::new(), locals);
                 self.run_frame(frame)
             }
             PyObjectKind::Class { name: _ } => self.new_instance(func_ref.clone(), args),

Original file line number	Diff line number	Diff line change
`@@ -17,13 +17,15 @@ use std::fmt;`
`17`	`17`	`pub struct CodeObject {`
`18`	`18`	`pub instructions: Vec<Instruction>,`
`19`	`19`	`pub label_map: HashMap<Label, usize>,`
	`20`	`+ pub arg_names: Vec<String>,`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`impl CodeObject {`
`23`		`- pub fn new() -> CodeObject {`
	`24`	`+ pub fn new(arg_names : Vec<String>) -> CodeObject {`
`24`	`25`	`CodeObject {`
`25`	`26`	`instructions: Vec::new(),`
`26`	`27`	`label_map: HashMap::new(),`
	`28`	`+ arg_names: arg_names,`
`27`	`29`	`}`
`28`	`30`	`}`
`29`	`31`	`}`