Add modules, better globals support, and call stack.

Author: progval

src/lib.rs

@@ -2,12 +2,13 @@ mod marshal;
 mod objects;
 mod processor;
 mod sandbox;
-mod stack;
+mod varstack;
 mod primitives;
 
 use std::fmt;
 use std::io;
-use processor::{PyResult, Processor};
+use std::collections::HashMap;
+pub use processor::{PyResult, Processor};
 
 pub use sandbox::{EnvProxy, RealEnvProxy, MockEnvProxy};
 
@@ -37,7 +38,7 @@ pub fn run_file<R: io::Read, EP: sandbox::EnvProxy>(reader: &mut R, envproxy: EP
     let mut store = objects::ObjectStore::new();
     let primitive_objects = objects::PrimitiveObjects::new(&mut store);
     let module = try!(marshal::read_object(reader, &mut store, &primitive_objects).map_err(InterpreterError::Unmarshal));
-    let mut processor = Processor { envproxy: envproxy, store: store, primitive_functions: primitives::get_default_primitives(), primitive_objects: primitive_objects };
+    let mut processor = Processor { envproxy: envproxy, store: store, primitive_functions: primitives::get_default_primitives(), primitive_objects: primitive_objects, modules: HashMap::new(), };
     let result = processor.run_code_object(module);
     Ok((processor, result))
 }

src/objects/mod.rs

@@ -48,10 +48,11 @@ pub enum ObjectContent {
     Set(Vec<ObjectRef>),
     FrozenSet(Vec<ObjectRef>),
     Bytes(Vec<u8>),
-    Function(ObjectRef),
+    Function(String, ObjectRef), // module, code
     PrimitiveNamespace, // __primitives__
     PrimitiveFunction(String),
     Class(Option<ObjectRef>),
+    Module,
     OtherObject,
 }
 
@@ -114,10 +115,10 @@ impl ObjectRef {
             ObjectContent::Code(_) => "<code object>".to_string(),
             ObjectContent::Set(ref l) => format!("set({})", ObjectRef::repr_vec(l, store)),
             ObjectContent::FrozenSet(ref l) => format!("frozenset({})", ObjectRef::repr_vec(l, store)),
-            ObjectContent::Function(_) => {
+            ObjectContent::Function(ref module, ref _code) => {
                 match obj.name {
-                    None => "<anonymous function>".to_string(),
-                    Some(ref s) => format!("<function {}>", s),
+                    None => format!("<anonymous function in module {}>", module),
+                    Some(ref s) => format!("<function {} in module {}>", s, module),
                 }
             },
             ObjectContent::PrimitiveNamespace => "__primitives__".to_string(),
@@ -128,9 +129,25 @@ impl ObjectRef {
                     Some(ref s) => format!("<class {}>", s),
                 }
             },
+            ObjectContent::Module => {
+                match obj.name {
+                    None => "<anonymous module>".to_string(),
+                    Some(ref s) => format!("<module {}", s),
+                }
+            },
             ObjectContent::OtherObject => format!("<{} instance>", obj.class.repr(store)),
         }
     }
+
+    pub fn module(&self, store: &ObjectStore) -> String {
+        let func = store.deref(self);
+        let ref name = func.name;
+        match func.content {
+            ObjectContent::Function(ref module_name, ref _code) => module_name.clone(),
+            ObjectContent::Module => name.clone().unwrap(),
+            _ => panic!(format!("Not a function/module: {:?}", func)),
+        }
+    }
 }
 
 
@@ -203,6 +220,8 @@ pub struct PrimitiveObjects {
     pub baseexception: ObjectRef,
     pub runtimeerror: ObjectRef,
 
+    pub module: ObjectRef,
+
     pub names_map: HashMap<String, ObjectRef>,
 }
 
@@ -236,6 +255,8 @@ impl PrimitiveObjects {
         let baseexception = store.allocate(Object::new_class("BaseException".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
         let runtimeerror = store.allocate(Object::new_class("RuntimeError".to_string(), None, type_ref.clone(), vec![baseexception.clone()]));
 
+        let module = store.allocate(Object::new_class("module".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
+
         let mut map = HashMap::new();
         map.insert("object".to_string(), obj_ref.clone());
         map.insert("tuple".to_string(), type_ref.clone());
@@ -255,6 +276,7 @@ impl PrimitiveObjects {
         map.insert("code".to_string(), code_type.clone());
         map.insert("BaseException".to_string(), baseexception.clone());
         map.insert("RuntimeError".to_string(), runtimeerror.clone());
+        map.insert("module".to_string(), module.clone());
 
         PrimitiveObjects {
             object: obj_ref, type_: type_ref,
@@ -265,6 +287,7 @@ impl PrimitiveObjects {
             bytes_type: bytes_type, str_type: str_type,
             function_type: function_type, code_type: code_type,
             baseexception: baseexception, runtimeerror: runtimeerror,
+            module: module,
             names_map: map,
         }
     }
@@ -293,4 +316,10 @@ impl PrimitiveObjects {
     pub fn new_code(&self, c: Code) -> Object {
         Object::new_instance(None, self.code_type.clone(), ObjectContent::Code(Box::new(c)))
     }
+    pub fn new_function(&self, name: String, module_name: String, code: ObjectRef) -> Object {
+        Object::new_instance(Some(name), self.function_type.clone(), ObjectContent::Function(module_name, code))
+    }
+    pub fn new_module(&self, name: String) -> Object {
+        Object::new_instance(Some(name), self.module.clone(), ObjectContent::Module)
+    }
 }

src/primitives/mod.rs

@@ -57,7 +57,7 @@ fn build_class<EP: EnvProxy>(processor: &mut Processor<EP>, args: Vec<ObjectRef>
     let mut args_iter = args.into_iter();
     parse_first_arguments!("__primitives__.build_class", processor.store, args, args_iter,
         "func" "a function": {
-            ObjectContent::Function(ref code_arg) => {
+            ObjectContent::Function(_, ref code_arg) => {
                 code = code_arg.clone();
             },
         },

src/processor/frame.rs

@@ -0,0 +1,31 @@
+use std::collections::HashMap;
+use std::rc::Rc;
+use std::cell::RefCell;
+use super::super::varstack::{VarStack, VectorVarStack};
+use super::super::objects::{ObjectRef, ObjectStore, ObjectContent};
+
+#[derive(Debug)]
+pub enum Block {
+    Loop(usize, usize), // begin, end
+    TryExcept(usize, usize), // begin, end
+}
+
+#[derive(Debug)]
+pub struct Frame {
+    pub object: ObjectRef,
+    pub var_stack: VectorVarStack<ObjectRef>,
+    pub block_stack: Vec<Block>,
+    pub locals: Rc<RefCell<HashMap<String, ObjectRef>>>,
+}
+
+impl Frame {
+    pub fn new(object: ObjectRef, locals: Rc<RefCell<HashMap<String, ObjectRef>>>) -> Frame {
+        Frame {
+            object: object,
+            var_stack: VectorVarStack::new(),
+            block_stack: Vec::new(),
+            locals: locals,
+        }
+    }
+}
+