Add new_instance method

windelbouwman · windelbouwman · commit e6493ec996b0 · 2018-07-14T12:14:16.000+02:00
diff --git a/parser/src/ast.rs b/parser/src/ast.rs
@@ -153,4 +153,8 @@ pub enum Comparison {
     LessOrEqual,
     Greater,
     GreaterOrEqual,
+    In,
+    NotIn,
+    Is,
+    IsNot,
 }
diff --git a/parser/src/python.lalrpop b/parser/src/python.lalrpop
@@ -133,6 +133,10 @@ CompOp: ast::Comparison = {
   "<=" => ast::Comparison::LessOrEqual,
   ">" => ast::Comparison::Greater,
   ">=" => ast::Comparison::GreaterOrEqual,
+  "in" => ast::Comparison::In,
+  "not" "in" => ast::Comparison::NotIn,
+  "is" => ast::Comparison::Is,
+  "is" "not" => ast::Comparison::IsNot,
 };
 
 Expression: ast::Expression = {
@@ -280,20 +284,22 @@ extern {
         "<=" => lexer::Tok::LessEqual,
         ">" => lexer::Tok::Greater,
         ">=" => lexer::Tok::GreaterEqual,
+        "as" => lexer::Tok::As,
         "assert" => lexer::Tok::Assert,
-        "import" => lexer::Tok::Import,
         "break" => lexer::Tok::Break,
+        "class" => lexer::Tok::Class,
         "continue" => lexer::Tok::Break,
-        "return" => lexer::Tok::Return,
-        "pass" => lexer::Tok::Pass,
-        "if" => lexer::Tok::If,
-        "while" => lexer::Tok::While,
+        "def" => lexer::Tok::Def,
         "for" => lexer::Tok::For,
+        "if" => lexer::Tok::If,
         "in" => lexer::Tok::In,
+        "is" => lexer::Tok::Is,
+        "import" => lexer::Tok::Import,
+        "not" => lexer::Tok::Not,
+        "pass" => lexer::Tok::Pass,
+        "return" => lexer::Tok::Return,
+        "while" => lexer::Tok::While,
         "with" => lexer::Tok::With,
-        "as" => lexer::Tok::As,
-        "def" => lexer::Tok::Def,
-        "class" => lexer::Tok::Class,
         "True" => lexer::Tok::True,
         "False" => lexer::Tok::False,
         "None" => lexer::Tok::None,
diff --git a/src/main.rs b/src/main.rs
@@ -48,7 +48,7 @@ fn run_script(script_file: &String) {
     match parse(filepath) {
         Ok(program) => {
             debug!("Got ast: {:?}", program);
-            let bytecode = compile::compile(program);
+            let bytecode = compile::compile(program, compile::Mode::Exec);
             debug!("Code object: {:?}", bytecode);
             vm.evaluate(bytecode);
         }
diff --git a/vm/src/builtins.rs b/vm/src/builtins.rs
@@ -37,7 +37,7 @@ pub fn print(args: Vec<Rc<NativeType>>) -> NativeType {
 }
 */
 
-pub fn print(rt: &mut Executor, args: Vec<PyObjectRef>) -> Result<PyObjectRef, PyObjectRef> {
+pub fn print(rt: &mut Executor, args: Vec<PyObjectRef>) -> PyResult {
     // println!("Woot: {:?}", args);
     trace!("print called with {:?}", args);
     for a in args {
@@ -48,6 +48,16 @@ pub fn print(rt: &mut Executor, args: Vec<PyObjectRef>) -> Result<PyObjectRef, P
     Ok(rt.get_none())
 }
 
+pub fn compile(rt: &mut Executor, args: Vec<PyObjectRef>) -> PyResult {
+    // TODO
+    Ok(rt.new_bool(true))
+}
+
+pub fn locals(rt: &mut Executor, args: Vec<PyObjectRef>) -> PyResult {
+    // TODO
+    Ok(rt.new_bool(true))
+}
+
 /*
  * TODO
 pub fn len(args: Vec<Rc<NativeType>>) -> NativeType {
@@ -66,7 +76,7 @@ pub fn len(args: Vec<Rc<NativeType>>) -> NativeType {
 
 pub fn make_module(ctx: &PyContext) -> PyObjectRef {
     // scope[String::from("print")] = print;
-    let obj = PyObject::new(PyObjectKind::Module, ctx.type_type.clone());
+    let obj = PyObject::new(PyObjectKind::Module { name: "__builtins__".to_string() }, ctx.type_type.clone());
     obj.borrow_mut().dict.insert(
         String::from("print"),
         PyObject::new(PyObjectKind::RustFunction { function: print }, ctx.type_type.clone()),
diff --git a/vm/src/bytecode.rs b/vm/src/bytecode.rs
@@ -81,7 +81,7 @@ pub enum ComparisonOperator {
     In,
     NotIn,
     Is,
-    NotIs,
+    IsNot,
 }
 
 #[derive(Debug, Clone)]
diff --git a/vm/src/compile.rs b/vm/src/compile.rs
@@ -12,11 +12,16 @@ struct Compiler {
     nxt_label: usize,
 }
 
-pub fn compile(p: ast::Program) -> CodeObject {
+pub fn compile(p: ast::Program, mode: Mode) -> CodeObject {
     let mut compiler = Compiler::new();
     compiler.compile_program(p)
 }
 
+pub enum Mode {
+    Exec,
+    Eval,
+}
+
 type Label = usize;
 
 impl Compiler {
@@ -279,6 +284,10 @@ impl Compiler {
                     ast::Comparison::LessOrEqual => bytecode::ComparisonOperator::LessOrEqual,
                     ast::Comparison::Greater => bytecode::ComparisonOperator::Greater,
                     ast::Comparison::GreaterOrEqual => bytecode::ComparisonOperator::GreaterOrEqual,
+                    ast::Comparison::In => bytecode::ComparisonOperator::In,
+                    ast::Comparison::NotIn => bytecode::ComparisonOperator::NotIn,
+                    ast::Comparison::Is => bytecode::ComparisonOperator::Is,
+                    ast::Comparison::IsNot => bytecode::ComparisonOperator::IsNot,
                 };
                 let i = Instruction::CompareOperation { op: i };
                 self.emit(i);
diff --git a/vm/src/eval.rs b/vm/src/eval.rs
@@ -9,7 +9,7 @@ pub fn eval(vm: &mut VirtualMachine, source: &String) -> Result<PyObjectRef, PyO
     match parse_source(source) {
         Ok(program) => {
             debug!("Got ast: {:?}", program);
-            let bytecode = compile::compile(program);
+            let bytecode = compile::compile(program, compile::Mode::Eval);
             debug!("Code object: {:?}", bytecode);
             vm.evaluate(bytecode)
         }
diff --git a/vm/src/lib.rs b/vm/src/lib.rs
@@ -10,6 +10,7 @@ pub mod bytecode;
 pub mod compile;
 pub mod eval;
 mod objint;
+mod objstr;
 mod objtype;
 pub mod pyobject;
 mod vm;
diff --git a/vm/src/objint.rs b/vm/src/objint.rs
@@ -13,7 +13,7 @@ fn set_attr(a: &mut PyObjectRef, name: String, b: PyObjectRef) {
 */
 
 pub fn create_type(type_type: PyObjectRef) -> PyObjectRef {
-    let typ = PyObject::new(PyObjectKind::Type, type_type.clone());
+    let typ = PyObject::new(PyObjectKind::Class { name: "int".to_string() }, type_type.clone());
     typ.borrow_mut().dict.insert(
         "__str__".to_string(),
         PyObject::new(PyObjectKind::RustFunction { function: str }, type_type.clone()),
diff --git a/vm/src/objlist.rs b/vm/src/objlist.rs
@@ -0,0 +1,28 @@
+
+
+fn subscript(rt: Executor, a, b: PyObjectRef) -> PyResult {
+    match b.kind {
+            (&NativeType::List(ref l), &NativeType::Int(ref index)) => {
+                let pos_index = (index + l.borrow().len() as i32) % l.borrow().len() as i32;
+                curr_frame.stack.push(Rc::new(l.borrow()[pos_index as usize].clone()))
+            },
+            (&NativeType::List(ref l), &NativeType::Slice(ref opt_start, ref opt_stop, ref opt_step)) => {
+                let start = match opt_start {
+                    &Some(start) => ((start + l.borrow().len() as i32) % l.borrow().len() as i32) as usize,
+                    &None => 0,
+                };
+                let stop = match opt_stop {
+                    &Some(stop) => ((stop + l.borrow().len() as i32) % l.borrow().len() as i32) as usize,
+                    &None => l.borrow().len() as usize,
+                };
+                let step = match opt_step {
+                    //Some(step) => step as usize,
+                    &None => 1 as usize,
+                    _ => unimplemented!(),
+                };
+                // TODO: we could potentially avoid this copy and use slice
+                curr_frame.stack.push(Rc::new(NativeType::List(RefCell::new(l.borrow()[start..stop].to_vec()))));
+            },
+    }
+}
+
diff --git a/vm/src/objstr.rs b/vm/src/objstr.rs
@@ -0,0 +1,47 @@
+use super::pyobject::{PyObject, PyObjectKind, PyObjectRef, Executor, PyResult};
+
+fn str_pos(s: &String, p: i32) -> usize {
+    if p < 0 {
+        s.len() - ((-p) as usize)
+    } else if p as usize > s.len() {
+        s.len()
+    } else {
+        p as usize
+    }
+}
+
+pub fn subscript(rt: &mut Executor, value: &String, b: PyObjectRef) -> PyResult {
+    // let value = a
+    match &(*b.borrow()).kind {
+        &PyObjectKind::Integer { value: ref pos } => {
+            let idx = str_pos(value, *pos);
+            Ok(rt.new_str(value[idx..idx+1].to_string()))
+        },
+        &PyObjectKind::Slice {
+            ref start,
+            ref stop,
+            ref step,
+        } => {
+            let start2: usize = match start {
+                // &Some(_) => panic!("Bad start index for string slicing {:?}", start),
+                &Some(start) => str_pos(value, start),
+                &None => 0,
+            };
+            let stop2: usize = match stop {
+                &Some(stop) => str_pos(value, stop),
+                // &Some(_) => panic!("Bad stop index for string slicing"),
+                &None => value.len() as usize,
+            };
+            let step2: usize = match step {
+                //Some(step) => step as usize,
+                &None => 1 as usize,
+                _ => unimplemented!(),
+            };
+            Ok(rt.new_str(value[start2..stop2].to_string()))
+        },
+        _ => panic!(
+            "TypeError: indexing type {:?} with index {:?} is not supported (yet?)",
+            value, b
+        ),
+    }
+}
diff --git a/vm/src/objtype.rs b/vm/src/objtype.rs
@@ -9,7 +9,7 @@ use super::pyobject::{PyObject, PyObjectKind, PyObjectRef};
 
 pub fn create_type() -> PyObjectRef {
     let typ = PyObject::default().into_ref();
-    (*typ.borrow_mut()).kind = PyObjectKind::Type;
+    (*typ.borrow_mut()).kind = PyObjectKind::Class { name: "type".to_string() };
     (*typ.borrow_mut()).typ = Some(typ.clone());
     // typ.borrow_mut().dict.insert("__str__".to_string(), PyObject::new(PyObjectKind::RustFunction { function: str }));
     typ
diff --git a/vm/src/pyobject.rs b/vm/src/pyobject.rs
@@ -65,6 +65,16 @@ impl PyContext {
     pub fn new_bool(&self, b: bool) -> PyObjectRef {
         PyObject::new(PyObjectKind::Boolean { value: b }, self.type_type.clone())
     }
+
+    pub fn new_class(&self, name: String) -> PyObjectRef {
+        PyObject::new(PyObjectKind::Class { name: name }, self.type_type.clone())
+    }
+
+    /* TODO: something like this?
+    pub fn new_instance(&self, name: String) -> PyObjectRef {
+        PyObject::new(PyObjectKind::Class { name: name }, self.type_type.clone())
+    }
+    */
 }
 
 pub trait Executor {
@@ -76,7 +86,6 @@ pub trait Executor {
     fn context(&self) -> &PyContext;
 }
 
-#[derive(Debug)]
 pub struct PyObject {
     pub kind: PyObjectKind,
     pub typ: Option<PyObjectRef>,
@@ -93,6 +102,12 @@ impl Default for PyObject {
     }
 }
 
+impl fmt::Debug for PyObject {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        write!(f, "[PyObj {:?}]", self.kind)
+    }
+}
+
 type RustPyFunc = fn(rt: &mut Executor, Vec<PyObjectRef>) -> PyResult;
 
 // #[derive(Debug)]
@@ -132,17 +147,20 @@ pub enum PyObjectKind {
     Function {
         code: bytecode::CodeObject,
     },
-    Module,
+    Module { name: String },
     None,
-    Type,
+    Class { name: String },
     RustFunction {
         function: RustPyFunc,
     },
 }
 
 impl fmt::Debug for PyObjectKind {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "Some kind of python obj")
+        match self {
+            &PyObjectKind::String { ref value } => write!(f, "str[{}]", value),
+            _ => write!(f, "Some kind of python obj"),
+        }
     }
 }
 
@@ -169,6 +187,7 @@ impl PyObject {
         match self.kind {
             PyObjectKind::String { ref value } => value.clone(),
             PyObjectKind::Integer { ref value } => format!("{:?}", value),
+            PyObjectKind::Boolean { ref value } => format!("{:?}", value),
             PyObjectKind::List { ref elements } => format!(
                 "[{}]",
                 elements
@@ -186,6 +205,11 @@ impl PyObject {
                     .join(", ")
             ),
             PyObjectKind::None => String::from("None"),
+            PyObjectKind::Class { ref name } => format!("<class '{}'>", name),
+            PyObjectKind::Code { code: _ } => format!("<code>"),
+            PyObjectKind::Function { code: _ } => format!("<func>"),
+            PyObjectKind::RustFunction { function: _ } => format!("<rustfunc>"),
+            PyObjectKind::Module { ref name }=> format!("<module '{}'>", name),
             _ => {
                 println!("Not impl {:?}", self);
                 panic!("Not impl");
diff --git a/vm/src/vm.rs b/vm/src/vm.rs

Original file line number	Diff line number	Diff line change
`@@ -153,4 +153,8 @@ pub enum Comparison {`
`153`	`153`	`LessOrEqual,`
`154`	`154`	`Greater,`
`155`	`155`	`GreaterOrEqual,`
	`156`	`+ In,`
	`157`	`+ NotIn,`
	`158`	`+ Is,`
	`159`	`+ IsNot,`
`156`	`160`	`}`
Original file line number	Diff line number	Diff line change
`@@ -48,7 +48,7 @@ fn run_script(script_file: &String) {`
`48`	`48`	`match parse(filepath) {`
`49`	`49`	`Ok(program) => {`
`50`	`50`	`debug!("Got ast: {:?}", program);`
`51`		`- let bytecode = compile::compile(program);`
	`51`	`+ let bytecode = compile::compile(program, compile::Mode::Exec);`
`52`	`52`	`debug!("Code object: {:?}", bytecode);`
`53`	`53`	`vm.evaluate(bytecode);`
`54`	`54`	`}`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ pub enum ComparisonOperator {`
`81`	`81`	`In,`
`82`	`82`	`NotIn,`
`83`	`83`	`Is,`
`84`		`- NotIs,`
	`84`	`+ IsNot,`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`#[derive(Debug, Clone)]`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ pub fn eval(vm: &mut VirtualMachine, source: &String) -> Result<PyObjectRef, PyO`
`9`	`9`	`match parse_source(source) {`
`10`	`10`	`Ok(program) => {`
`11`	`11`	`debug!("Got ast: {:?}", program);`
`12`		`- let bytecode = compile::compile(program);`
	`12`	`+ let bytecode = compile::compile(program, compile::Mode::Eval);`
`13`	`13`	`debug!("Code object: {:?}", bytecode);`
`14`	`14`	`vm.evaluate(bytecode)`
`15`	`15`	`}`