Implement for loops.

progval · progval · commit 45dc24cbb576 · 2016-05-07T18:26:52.000+02:00
diff --git a/functional_tests/for_loop.py b/functional_tests/for_loop.py
@@ -0,0 +1,5 @@
+mytuple = (1, 2, 4, 8, 16, 42)
+for n in mytuple:
+    print(n)
+
+print('end')
diff --git a/src/objects/mod.rs b/src/objects/mod.rs
@@ -3,6 +3,8 @@ use std::collections::HashMap;
 use std::sync::atomic::{AtomicUsize, Ordering, ATOMIC_USIZE_INIT};
 use std::fmt;
 use self::itertools::Itertools;
+use super::state::State;
+use super::sandbox::EnvProxy;
 
 #[derive(Debug)]
 #[derive(Clone)]
@@ -53,25 +55,44 @@ pub enum ObjectContent {
     PrimitiveNamespace, // __primitives__
     PrimitiveFunction(String),
     Class(Option<ObjectRef>),
+    RandomAccessIterator(ObjectRef, usize, u64), // container, index, container version
     OtherObject,
 }
 
+static CURRENT_VERSION: AtomicUsize = ATOMIC_USIZE_INIT;
+
 #[derive(Debug)]
 #[derive(Clone)]
 pub struct Object {
+    pub version: u64,
     pub name: Option<String>,
     pub content: ObjectContent,
     pub class: ObjectRef,
     pub bases: Option<Vec<ObjectRef>>, // superclasses
 }
 
 impl Object {
+    fn new_version() -> u64 {
+        CURRENT_VERSION.fetch_add(1, Ordering::SeqCst) as u64 // TODO: avoid cast
+    }
     pub fn new_instance(name: Option<String>, class: ObjectRef, content: ObjectContent) -> Object {
-        Object { name: name, content: content, class: class, bases: None }
+        Object {
+            version: Object::new_version(),
+            name: name,
+            content: content,
+            class: class,
+            bases: None,
+        }
     }
 
     pub fn new_class(name: String, code: Option<ObjectRef>, metaclass: ObjectRef, bases: Vec<ObjectRef>) -> Object {
-        Object { name: Some(name), content: ObjectContent::Class(code), class: metaclass, bases: Some(bases) }
+        Object {
+            version: Object::new_version(),
+            name: Some(name),
+            content: ObjectContent::Class(code),
+            class: metaclass,
+            bases: Some(bases),
+        }
     }
 }
 
@@ -135,6 +156,9 @@ impl ObjectRef {
                     Some(ref s) => format!("<module {}", s),
                 }
             },
+            ObjectContent::RandomAccessIterator(ref container, ref index, ref version) => {
+                format!("<iterator on {} at index {}>", store.deref(container).class.repr(store), version)
+            }
             ObjectContent::OtherObject => format!("<{} instance>", obj.class.repr(store)),
         }
     }
@@ -148,6 +172,13 @@ impl ObjectRef {
             _ => panic!(format!("Not a function/module: {:?}", func)),
         }
     }
+
+    pub fn iter<EP: EnvProxy>(&self, state: &mut State<EP>) -> ObjectRef {
+        // TODO: check it's a list or a tuple
+        let obj_version = state.store.deref(self).version;
+        let iterator = Object::new_instance(None, state.primitive_objects.iterator_type.clone(), ObjectContent::RandomAccessIterator(self.clone(), 0, obj_version));
+        state.store.allocate(iterator)
+    }
 }
 
 
@@ -214,6 +245,8 @@ pub struct PrimitiveObjects {
     pub bytes_type: ObjectRef,
     pub str_type: ObjectRef,
 
+    pub iterator_type: ObjectRef,
+
     pub function_type: ObjectRef,
     pub code_type: ObjectRef,
 
@@ -226,6 +259,7 @@ pub struct PrimitiveObjects {
     pub nameerror: ObjectRef,
     pub attributeerror: ObjectRef,
     pub typeerror: ObjectRef,
+    pub stopiteration: ObjectRef,
 
     pub lookuperror: ObjectRef,
     pub keyerror: ObjectRef,
@@ -237,8 +271,20 @@ impl PrimitiveObjects {
     pub fn new(store: &mut ObjectStore) -> PrimitiveObjects {
         let obj_ref = ObjectRef::new();
         let type_ref = ObjectRef::new();
-        let obj = Object { name: Some("object".to_string()), content: ObjectContent::OtherObject, bases: Some(vec![]), class: type_ref.clone() };
-        let type_ = Object { name: Some("type".to_string()), content: ObjectContent::OtherObject, bases: Some(vec![obj_ref.clone()]), class: type_ref.clone() };
+        let obj = Object {
+            version: Object::new_version(),
+            name: Some("object".to_string()),
+            content: ObjectContent::OtherObject,
+            bases: Some(vec![]),
+            class: type_ref.clone()
+        };
+        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()
+        };
         store.allocate_at(obj_ref.clone(), obj);
         store.allocate_at(type_ref.clone(), type_);
 
@@ -256,6 +302,7 @@ impl PrimitiveObjects {
         let frozenset_type = store.allocate(Object::new_class("frozenset".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
         let bytes_type = store.allocate(Object::new_class("bytes".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
         let str_type = store.allocate(Object::new_class("str".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
+        let iterator_type = store.allocate(Object::new_class("iterator".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
 
         let function_type = store.allocate(Object::new_class("function".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
         let code_type = store.allocate(Object::new_class("code".to_string(), None, type_ref.clone(), vec![obj_ref.clone()]));
@@ -269,6 +316,7 @@ impl PrimitiveObjects {
         let nameerror = store.allocate(Object::new_class("NameError".to_string(), None, type_ref.clone(), vec![exception.clone()]));
         let attributeerror = store.allocate(Object::new_class("AttributeError".to_string(), None, type_ref.clone(), vec![exception.clone()]));
         let typeerror = store.allocate(Object::new_class("TypeError".to_string(), None, type_ref.clone(), vec![exception.clone()]));
+        let stopiteration = store.allocate(Object::new_class("StopIteration".to_string(), None, type_ref.clone(), vec![exception.clone()]));
 
         let lookuperror = store.allocate(Object::new_class("LookupError".to_string(), None, type_ref.clone(), vec![exception.clone()]));
         let keyerror = store.allocate(Object::new_class("KeyError".to_string(), None, type_ref.clone(), vec![lookuperror.clone()]));
@@ -301,6 +349,7 @@ impl PrimitiveObjects {
         map.insert("NameError".to_string(), nameerror.clone());
         map.insert("AttributeError".to_string(), attributeerror.clone());
         map.insert("TypeError".to_string(), typeerror.clone());
+        map.insert("StopIteration".to_string(), stopiteration.clone());
 
         map.insert("LookupError".to_string(), lookuperror.clone());
         map.insert("KeyError".to_string(), keyerror.clone());
@@ -312,9 +361,10 @@ impl PrimitiveObjects {
             tuple_type: tuple_type, list_type: list_type,
             set_type: set_type, frozenset_type: frozenset_type,
             bytes_type: bytes_type, str_type: str_type,
+            iterator_type: iterator_type,
             function_type: function_type, code_type: code_type,
             baseexception: baseexception, processorerror: processorerror, exception: exception,
-            nameerror: nameerror, attributeerror: attributeerror, typeerror: typeerror,
+            nameerror: nameerror, attributeerror: attributeerror, typeerror: typeerror, stopiteration: stopiteration,
             lookuperror: lookuperror, keyerror: keyerror,
             module: module,
             names_map: map,
diff --git a/src/primitives/mod.rs b/src/primitives/mod.rs
@@ -2,8 +2,9 @@ use std::collections::{HashMap, HashSet};
 use std::io::Write;
 use std::collections::linked_list::LinkedList;
 use super::sandbox::EnvProxy;
-use super::state::{State, PyResult, PyFunction};
-use super::objects::{ObjectRef, ObjectContent, Object};
+use super::state::{State, PyResult, PyFunction, raise, return_value};
+use super::objects::{ObjectRef, ObjectContent, Object, ObjectStore};
+use super::processor::frame::Frame;
 
 macro_rules! parse_first_arguments {
     ( $funcname:expr, $store:expr, $args:ident, $args_iter:ident, $( $argname:tt $argexpected:tt : { $($argpattern:pat => $argcode:block,)* } ),* ) => {{
@@ -31,7 +32,7 @@ macro_rules! parse_arguments {
     }};
 }
 
-fn write_stdout<EP: EnvProxy>(processor: &mut State<EP>, args: Vec<ObjectRef>) -> PyResult {
+fn write_stdout<EP: EnvProxy>(processor: &mut State<EP>, call_stack: &mut Vec<Frame>, args: Vec<ObjectRef>) {
     parse_arguments!("__primitives__.write_stdout", processor.store, args,
         "value" "a string, boolean, or integer": {
             ObjectContent::String(ref s) => {
@@ -48,10 +49,10 @@ fn write_stdout<EP: EnvProxy>(processor: &mut State<EP>, args: Vec<ObjectRef>) -
             },
         }
     );
-    PyResult::Return(processor.primitive_objects.none.clone())
+    return_value(call_stack, processor.primitive_objects.none.clone())
 }
 
-fn build_class<EP: EnvProxy>(processor: &mut State<EP>, args: Vec<ObjectRef>) -> PyResult {
+fn build_class<EP: EnvProxy>(processor: &mut State<EP>, call_stack: &mut Vec<Frame>, args: Vec<ObjectRef>) {
     let name;
     let code;
     let mut args_iter = args.into_iter();
@@ -72,15 +73,10 @@ fn build_class<EP: EnvProxy>(processor: &mut State<EP>, args: Vec<ObjectRef>) ->
     else {
         bases
     };
-    PyResult::Return(processor.store.allocate(Object::new_class(name, Some(code), processor.primitive_objects.type_.clone(), bases)))
+    return_value(call_stack, processor.store.allocate(Object::new_class(name, Some(code), processor.primitive_objects.type_.clone(), bases)))
 }
 
-fn issubclass<EP: EnvProxy>(processor: &mut State<EP>, args: Vec<ObjectRef>) -> PyResult {
-    if args.len() != 2 {
-        panic!(format!("__primitives__.issubclass takes 2 arguments, not {}", args.len()))
-    }
-    let first = args.get(0).unwrap();
-    let second = args.get(1).unwrap();
+pub fn native_issubclass(store: &ObjectStore, first: &ObjectRef, second: &ObjectRef) -> bool {
     let mut visited = HashSet::new();
     let mut to_visit = LinkedList::new();
     to_visit.push_back(first.clone());
@@ -90,9 +86,9 @@ fn issubclass<EP: EnvProxy>(processor: &mut State<EP>, args: Vec<ObjectRef>) ->
             continue
         };
         if candidate.is(second) {
-            return PyResult::Return(processor.primitive_objects.true_obj.clone())
+            return true
         };
-        match processor.store.deref(&candidate).bases {
+        match store.deref(&candidate).bases {
             None => (),
             Some(ref bases) => {
                 for base in bases.iter() {
@@ -101,17 +97,81 @@ fn issubclass<EP: EnvProxy>(processor: &mut State<EP>, args: Vec<ObjectRef>) ->
             }
         };
     }
-    PyResult::Return(processor.primitive_objects.false_obj.clone())
+    false
 }
 
-fn isinstance<EP: EnvProxy>(processor: &mut State<EP>, mut args: Vec<ObjectRef>) -> PyResult {
+fn issubclass<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, args: Vec<ObjectRef>) {
+    if args.len() != 2 {
+        panic!(format!("__primitives__.issubclass takes 2 arguments, not {}", args.len()))
+    }
+    let first = args.get(0).unwrap();
+    let second = args.get(1).unwrap();
+    let res = native_issubclass(&state.store, first, second);
+    if res {
+        return_value(call_stack, state.primitive_objects.true_obj.clone())
+    }
+    else {
+        return_value(call_stack, state.primitive_objects.false_obj.clone())
+    }
+}
+
+pub fn native_isinstance(store: &ObjectStore, first: &ObjectRef, second: &ObjectRef) -> bool {
+    native_issubclass(store, &store.deref(&first).class, second)
+}
+
+fn isinstance<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, mut args: Vec<ObjectRef>) {
     if args.len() != 2 {
         panic!(format!("__primitives__.isinstance takes 2 arguments, not {}", args.len()))
     }
     let second = args.pop().unwrap();
     let first = args.pop().unwrap();
-    let new_args = vec![processor.store.deref(&first).class.clone(), second];
-    issubclass(processor, new_args)
+    let res = native_isinstance(&state.store, &first, &second);
+    if res {
+        return_value(call_stack, state.primitive_objects.true_obj.clone())
+    }
+    else {
+        return_value(call_stack, state.primitive_objects.false_obj.clone())
+    }
+}
+
+fn iter<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>, mut args: Vec<ObjectRef>) {
+    if args.len() != 1 {
+        panic!(format!("__primitives__.iter takes 1 arguments, not {}", args.len()))
+    }
+    let iterator_ref = args.last().unwrap();
+    let iterator = state.store.deref(iterator_ref).clone();
+    match iterator.content {
+        ObjectContent::RandomAccessIterator(container_ref, index, container_version) => {
+            let value = {
+                let container = state.store.deref(&container_ref);
+                if container.version != container_version {
+                    panic!("Container changed while iterating.")
+                };
+                match container.content {
+                    ObjectContent::List(ref v) | ObjectContent::Tuple(ref v) => v.get(index).map(|r| r.clone()),
+                    ref c => panic!(format!("RandomAccessIterator does not support {}", container_ref.repr(&state.store)))
+                }
+            };
+            match value {
+                Some(value) => {
+                    let mut iterator = state.store.deref_mut(iterator_ref);
+                    iterator.content = ObjectContent::RandomAccessIterator(container_ref, index+1, container_version);
+                    return_value(call_stack, value.clone())
+                }
+                None => {
+                    let stopiteration = state.primitive_objects.stopiteration.clone();
+
+                    return raise(state, call_stack, stopiteration, "StopIteration instance".to_string())
+                }
+            }
+        }
+        ref c =>  {
+            let repr = iterator_ref.repr(&state.store);
+            let exc = Object::new_instance(None, state.primitive_objects.typeerror.clone(), ObjectContent::OtherObject);
+            let exc = state.store.allocate(exc);
+            raise(state, call_stack, exc, format!("{} is not an iterator", repr));
+        }
+    }
 }
 
 
@@ -121,5 +181,6 @@ pub fn get_default_primitives<EP: EnvProxy>() -> HashMap<String, PyFunction<EP>>
     builtins.insert("build_class".to_string(), build_class);
     builtins.insert("issubclass".to_string(), issubclass);
     builtins.insert("isinstance".to_string(), isinstance);
+    builtins.insert("iter".to_string(), iter);
     builtins
 }
diff --git a/src/processor/frame.rs b/src/processor/frame.rs
@@ -9,6 +9,7 @@ use super::instructions::{Instruction, InstructionDecoder};
 pub enum Block {
     Loop(usize, usize), // begin, end
     TryExcept(usize, usize), // begin, end
+    ExceptPopGoto(ObjectRef, usize, usize), // If an exception matchs the first arg matches, pop n elements from the stack and set the PC to the second arg
 }
 
 #[derive(Debug)]
diff --git a/src/processor/instructions.rs b/src/processor/instructions.rs
@@ -42,19 +42,22 @@ pub enum Instruction {
     DupTop,
     Nop,
     BinarySubscr,
+    GetIter,
     LoadBuildClass,
     ReturnValue,
     PopBlock,
     EndFinally,
     PopExcept,
     StoreName(usize),
+    ForIter(usize),
     LoadConst(usize),
     LoadName(usize),
     LoadAttr(usize),
     SetupLoop(usize),
     SetupExcept(usize),
     CompareOp(CmpOperator),
     JumpForward(usize),
+    JumpAbsolute(usize),
     PopJumpIfFalse(usize),
     LoadFast(usize),
     LoadGlobal(usize),
@@ -108,17 +111,20 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
                 1 => Instruction::PopTop,
                 4 => Instruction::DupTop,
                 25 => Instruction::BinarySubscr,
+                68 => Instruction::GetIter,
                 71 => Instruction::LoadBuildClass,
                 83 => Instruction::ReturnValue,
                 87 => Instruction::PopBlock,
                 88 => Instruction::EndFinally,
                 89 => Instruction::PopExcept,
                 90 => Instruction::StoreName(self.read_argument() as usize),
+                93 => Instruction::ForIter(self.read_argument() as usize),
                 100 => Instruction::LoadConst(self.read_argument() as usize),
                 101 => Instruction::LoadName(self.read_argument() as usize),
                 106 => Instruction::LoadAttr(self.read_argument() as usize),
                 107 => Instruction::CompareOp(CmpOperator::from_bytecode(self.read_argument())),
                 110 => Instruction::JumpForward(self.read_argument() as usize + 2), // +2, because JumpForward takes 3 bytes, and the relative address is computed from the next instruction.
+                113 => Instruction::JumpAbsolute(self.read_argument() as usize),
                 114 => Instruction::PopJumpIfFalse(self.read_argument() as usize),
                 116 => Instruction::LoadGlobal(self.read_argument() as usize),
                 120 => Instruction::SetupLoop(self.read_argument() as usize + 2),
diff --git a/src/processor/mod.rs b/src/processor/mod.rs
diff --git a/src/state.rs b/src/state.rs

Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,7 @@ use super::instructions::{Instruction, InstructionDecoder};`
`9`	`9`	`pub enum Block {`
`10`	`10`	`Loop(usize, usize), // begin, end`
`11`	`11`	`TryExcept(usize, usize), // begin, end`
	`12`	`+ ExceptPopGoto(ObjectRef, usize, usize), // If an exception matchs the first arg matches, pop n elements from the stack and set the PC to the second arg`
`12`	`13`	`}`
`13`	`14`
`14`	`15`	`#[derive(Debug)]`