Add support for class attributes.

Author: progval

run_functional_tests.py

@@ -3,6 +3,7 @@
 import os
 import sys
 import glob
+import traceback
 import subprocess
 
 SOURCE_DIR = os.path.dirname('__file__')
@@ -17,19 +18,24 @@
 
 for filename in glob.glob(TESTS_DIR + os.path.sep + '*.py'):
     print('Running test: {}'.format(filename))
-    vm_result = subprocess.check_output([BIN, LIB_DIR, filename + 'c'], universal_newlines=True)
     system_python_result = subprocess.check_output([sys.executable, filename], universal_newlines=True)
-    if vm_result != system_python_result:
-        print('=' * 100)
-        print('Test {} failed.'.format(filename))
-        print('-' * 100)
-        print('System Python:')
-        print(system_python_result)
-        print('-' * 100)
-        print('VM result:')
-        print(vm_result)
-        print('=' * 100)
+    try:
+        vm_result = subprocess.check_output([BIN, LIB_DIR, filename + 'c'], universal_newlines=True)
+    except subprocess.CalledProcessError as e:
+        traceback.print_exc()
         all_ok = False
+    else:
+        if vm_result != system_python_result:
+            print('=' * 100)
+            print('Test {} failed.'.format(filename))
+            print('-' * 100)
+            print('System Python:')
+            print(system_python_result)
+            print('-' * 100)
+            print('VM result:')
+            print(vm_result)
+            print('=' * 100)
+            all_ok = False
 
 if all_ok:
     exit(0)

src/objects/mod.rs

@@ -2,6 +2,9 @@ extern crate itertools;
 use std::collections::HashMap;
 use std::collections::HashSet;
 use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
+use std::borrow::Cow;
+use std::rc::Rc;
+use std::cell::RefCell;
 use std::fmt;
 use self::itertools::Itertools;
 use super::state::State;
@@ -86,7 +89,7 @@ pub enum ObjectContent {
     Module(ObjectRef),
     PrimitiveNamespace, // __primitives__
     PrimitiveFunction(String),
-    Class(Option<ObjectRef>),
+    Class,
     RandomAccessIterator(ObjectRef, usize, u64), // container, index, container version
     OtherObject,
 }
@@ -101,6 +104,7 @@ pub struct Object {
     pub content: ObjectContent,
     pub class: ObjectRef,
     pub bases: Option<Vec<ObjectRef>>, // superclasses
+    pub attributes: Option<Rc<RefCell<HashMap<String, ObjectRef>>>>,
 }
 
 impl Object {
@@ -114,16 +118,18 @@ impl Object {
             content: content,
             class: class,
             bases: None,
+            attributes: Some(Rc::new(RefCell::new(HashMap::new()))),
         }
     }
 
-    pub fn new_class(name: String, code: Option<ObjectRef>, metaclass: ObjectRef, bases: Vec<ObjectRef>) -> Object {
+    pub fn new_class(name: String, attributes: Option<Rc<RefCell<HashMap<String, ObjectRef>>>>, metaclass: ObjectRef, bases: Vec<ObjectRef>) -> Object {
         Object {
             version: Object::new_version(),
             name: Some(name),
-            content: ObjectContent::Class(code),
+            content: ObjectContent::Class,
             class: metaclass,
             bases: Some(bases),
+            attributes: attributes,
         }
     }
 }
@@ -177,7 +183,7 @@ impl ObjectRef {
             },
             ObjectContent::PrimitiveNamespace => "__primitives__".to_string(),
             ObjectContent::PrimitiveFunction(ref s) => format!("__primitives__.{}", s),
-            ObjectContent::Class(_) => {
+            ObjectContent::Class => {
                 match obj.name {
                     None => "<anonymous class>".to_string(),
                     Some(ref s) => format!("<class {}>", s),
@@ -212,6 +218,13 @@ impl ObjectRef {
         let iterator = Object::new_instance(None, state.primitive_objects.iterator_type.clone(), ObjectContent::RandomAccessIterator(self.clone(), 0, obj_version));
         state.store.allocate(iterator)
     }
+
+    pub fn setattr(&self, store: &mut ObjectStore, name: String, value: ObjectRef) {
+        match store.deref(self).attributes {
+            Some(ref attributes) => attributes.borrow_mut().insert(name, value),
+            None => panic!("{}'s attributes are not settable.", self.repr(store)),
+        };
+    }
 }
 
 
@@ -310,14 +323,16 @@ impl PrimitiveObjects {
             name: Some("object".to_string()),
             content: ObjectContent::OtherObject,
             bases: Some(vec![]),
-            class: type_ref.clone()
+            class: type_ref.clone(),
+            attributes: None,
         };
         let type_ = Object {
             version: Object::new_version(),
             name: Some("type".to_string()),
             content: ObjectContent::OtherObject,
             bases: Some(vec![obj_ref.clone()]),
-            class: type_ref.clone()
+            class: type_ref.clone(),
+            attributes: None,
         };
         store.allocate_at(obj_ref.clone(), obj);
         store.allocate_at(type_ref.clone(), type_);

src/primitives/mod.rs

@@ -1,10 +1,15 @@
 use std::collections::{HashMap, HashSet};
 use std::io::Write;
 use std::collections::linked_list::LinkedList;
+use std::rc::Rc;
+use std::cell::RefCell;
+use std::iter::IntoIterator;
 use super::sandbox::EnvProxy;
 use super::state::{State, PyResult, PyFunction, raise, return_value};
 use super::objects::{ObjectRef, ObjectContent, Object, ObjectStore};
 use super::processor::frame::Frame;
+use super::processor::instructions::{Instruction, InstructionDecoder};
+use super::varstack::{VarStack, VectorVarStack};
 
 macro_rules! parse_first_arguments {
     ( $funcname:expr, $store:expr, $args:ident, $args_iter:ident, $( $argname:tt $argexpected:tt : { $($argpattern:pat => $argcode:block,)* } ),* ) => {{
@@ -52,14 +57,17 @@ fn write_stdout<EP: EnvProxy>(processor: &mut State<EP>, call_stack: &mut Vec<Fr
     return_value(call_stack, processor.primitive_objects.none.clone())
 }
 
-fn build_class<EP: EnvProxy>(processor: &mut State<EP>, call_stack: &mut Vec<Frame>, args: Vec<ObjectRef>) {
+fn build_class<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, args: Vec<ObjectRef>) {
     let name;
     let code;
     let mut args_iter = args.into_iter();
-    parse_first_arguments!("__primitives__.build_class", processor.store, args, args_iter,
+    parse_first_arguments!("__primitives__.build_class", state.store, args, args_iter,
         "func" "a function": {
             ObjectContent::Function(_, ref code_arg, _) => {
-                code = code_arg.clone();
+                match state.store.deref(code_arg).content {
+                    ObjectContent::Code(ref code_) => code = code_.clone(),
+                    _ => panic!("__build_class__'s function argument has a code that is not code.")
+                }
             },
         },
         "name" "a string": {
@@ -68,12 +76,34 @@ fn build_class<EP: EnvProxy>(processor: &mut State<EP>, call_stack: &mut Vec<Fra
     );
     let bases: Vec<ObjectRef> = args_iter.collect();
     let bases = if bases.len() == 0 {
-        vec![processor.primitive_objects.object.clone()]
+        vec![state.primitive_objects.object.clone()]
     }
     else {
         bases
     };
-    return_value(call_stack, processor.store.allocate(Object::new_class(name, Some(code), processor.primitive_objects.type_.clone(), bases)))
+
+
+    let mut attributes = Rc::new(RefCell::new(HashMap::new()));
+    let cls_ref = state.store.allocate(Object::new_class(name, Some(attributes.clone()), state.primitive_objects.type_.clone(), bases));
+
+    let mut instructions: Vec<Instruction> = InstructionDecoder::new(code.code.iter()).collect();
+
+    // Hack to made the class' code return the class instead of None
+    assert_eq!(instructions.pop(), Some(Instruction::ReturnValue));
+    instructions.pop(); // LoadConst None
+    instructions.push(Instruction::PushImmediate(cls_ref.clone()));
+    instructions.push(Instruction::ReturnValue);
+
+    let mut frame = Frame {
+        object: cls_ref,
+        var_stack: VectorVarStack::new(),
+        block_stack: vec![],
+        locals: attributes,
+        instructions: instructions,
+        code: (*code).clone(),
+        program_counter: 0,
+    };
+    call_stack.push(frame);
 }
 
 pub fn native_issubclass(store: &ObjectStore, first: &ObjectRef, second: &ObjectRef) -> bool {

src/processor/instructions.rs

@@ -1,3 +1,5 @@
+use super::super::objects::ObjectRef;
+
 #[derive(PartialEq)]
 #[derive(Debug)]
 #[derive(Clone)]
@@ -38,6 +40,8 @@ impl CmpOperator {
 #[derive(Debug)]
 #[derive(Clone)]
 pub enum Instruction {
+    PushImmediate(ObjectRef),
+
     PopTop,
     DupTop,
     Nop,
@@ -50,6 +54,8 @@ pub enum Instruction {
     PopExcept,
     StoreName(usize),
     ForIter(usize),
+    StoreAttr(usize),
+    StoreGlobal(usize),
     LoadConst(usize),
     LoadName(usize),
     BuildTuple(usize),
@@ -130,6 +136,8 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
                 89 => Instruction::PopExcept,
                 90 => Instruction::StoreName(self.read_argument() as usize),
                 93 => Instruction::ForIter(self.read_argument() as usize),
+                95 => Instruction::StoreAttr(self.read_argument() as usize),
+                97 => Instruction::StoreGlobal(self.read_argument() as usize),
                 100 => Instruction::LoadConst(self.read_argument() as usize),
                 101 => Instruction::LoadName(self.read_argument() as usize),
                 102 => Instruction::BuildTuple(self.read_argument() as usize),

src/processor/mod.rs

@@ -123,7 +123,11 @@ fn load_attr<EP: EnvProxy>(state: &mut State<EP>, obj: &Object, name: &String) -
                 }
             }
             else {
-                panic!(format!("Not implemented: looking up attribute '{}' of {:?}", name, obj))
+                // TODO: special names
+                match obj.attributes {
+                    Some(ref attributes) => attributes.borrow().get(name).map(|r| r.clone()),
+                    None => None,
+                }
             }
         }
     }
@@ -133,12 +137,7 @@ fn load_attr<EP: EnvProxy>(state: &mut State<EP>, obj: &Object, name: &String) -
 fn call_function<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, func_ref: &ObjectRef, mut args: Vec<ObjectRef>, kwargs: Vec<(ObjectRef, ObjectRef)>) {
     // TODO: clone only if necessary
     match state.store.deref(func_ref).content.clone() {
-        ObjectContent::Class(None) => {
-            let frame = call_stack.last_mut().unwrap();
-            frame.var_stack.push(state.store.allocate(Object::new_instance(None, func_ref.clone(), ObjectContent::OtherObject)))
-        },
-        ObjectContent::Class(Some(ref code_ref)) => {
-            // TODO: run code
+        ObjectContent::Class => {
             let frame = call_stack.last_mut().unwrap();
             frame.var_stack.push(state.store.allocate(Object::new_instance(None, func_ref.clone(), ObjectContent::OtherObject)))
         },
@@ -236,7 +235,8 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
             let frame = call_stack.last_mut().unwrap();
             let instruction = py_unwrap!(state, frame.instructions.get(frame.program_counter), ProcessorError::InvalidProgramCounter);
             // Useful for debugging:
-            /*println!("");
+            /*
+            println!("");
             for r in frame.var_stack.iter() {
                 println!("{}", r.repr(&state.store));
             }
@@ -246,6 +246,10 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
             instruction.clone()
         };
         match instruction {
+            Instruction::PushImmediate(r) => {
+                let frame = call_stack.last_mut().unwrap();
+                frame.var_stack.push(r);
+            },
             Instruction::PopTop => {
                 let frame = call_stack.last_mut().unwrap();
                 pop_stack!(state, frame.var_stack);
@@ -368,6 +372,20 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
                 let iter_func = state.store.allocate(Object::new_instance(None, state.primitive_objects.function_type.clone(), ObjectContent::PrimitiveFunction("iter".to_string())));
                 call_function(state, call_stack, &iter_func, vec![iterator], vec![]);
             }
+            Instruction::StoreAttr(i) => {
+                let frame = call_stack.last_mut().unwrap();
+                let name = py_unwrap!(state, frame.code.names.get(i), ProcessorError::InvalidNameIndex).clone();
+                let owner = pop_stack!(state, frame.var_stack);
+                let value = pop_stack!(state, frame.var_stack);
+                owner.setattr(&mut state.store, name, value);
+                println!("{:?}", state.store.deref(&owner).attributes)
+            }
+            Instruction::StoreGlobal(i) => {
+                let frame = call_stack.last_mut().unwrap();
+                let name = py_unwrap!(state, frame.code.varnames.get(i), ProcessorError::InvalidVarnameIndex).clone();
+                let mut globals = state.modules.get(&frame.object.module(&state.store)).unwrap().borrow_mut();
+                globals.insert(name, pop_stack!(state, frame.var_stack));
+            }
             Instruction::LoadConst(i) => {
                 let frame = call_stack.last_mut().unwrap();
                 frame.var_stack.push(py_unwrap!(state, frame.code.consts.get(i), ProcessorError::InvalidConstIndex).clone())
@@ -408,7 +426,7 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
                 match res {
                     None => {
                         let exc = state.primitive_objects.nameerror.clone();
-                        raise(state, call_stack, exc, format!("Unknown variable {}", name))
+                        raise(state, call_stack, exc, format!("Unknown attribute {}", name))
                     },
                     Some(obj_ref) => {
                         let frame = call_stack.last_mut().unwrap();