Make print() support an arbitrary number of arguments.

progval · progval · commit b8dd10bee238 · 2016-05-07T21:25:57.000+02:00
diff --git a/functional_tests/print.py b/functional_tests/print.py
@@ -1 +1,2 @@
 print('foo')
+print('foo', 'bar')
diff --git a/pythonlib/builtins.py b/pythonlib/builtins.py
@@ -1,10 +1,18 @@
 BaseException = __primitives__.BaseException
 RuntimeError = __primitives__.RuntimeError
 
-def print(value):
-    __primitives__.write_stdout(value)
+def print(*values):
+    first = True
+    for value in values:
+        if first:
+            first = False
+        else:
+            __primitives__.write_stdout(" ")
+        __primitives__.write_stdout(value)
+
     __primitives__.write_stdout("\n")
 
 __build__class__ = __primitives__.build_class
 issubclass = __primitives__.issubclass
 isinstance = __primitives__.isinstance
+
diff --git a/src/processor/instructions.rs b/src/processor/instructions.rs
@@ -60,6 +60,7 @@ pub enum Instruction {
     JumpAbsolute(usize),
     PopJumpIfFalse(usize),
     LoadFast(usize),
+    StoreFast(usize),
     LoadGlobal(usize),
     CallFunction(usize, usize), // nb_args, nb_kwargs
     RaiseVarargs(u16),
@@ -130,6 +131,7 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
                 120 => Instruction::SetupLoop(self.read_argument() as usize + 2),
                 121 => Instruction::SetupExcept(self.read_argument() as usize + 2),
                 124 => Instruction::LoadFast(self.read_argument() as usize),
+                125 => Instruction::StoreFast(self.read_argument() as usize),
                 130 => Instruction::RaiseVarargs(self.read_argument() as u16),
                 131 => Instruction::CallFunction(self.read_byte() as usize, self.read_byte() as usize),
                 132 => {
diff --git a/src/processor/mod.rs b/src/processor/mod.rs
@@ -198,7 +198,13 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
         let instruction = {
             let frame = call_stack.last_mut().unwrap();
             let instruction = py_unwrap!(state, frame.instructions.get(frame.program_counter), ProcessorError::InvalidProgramCounter);
-            //println!("{} {:?}", frame.program_counter, instruction); // Useful for debugging
+            // Useful for debugging:
+            /*println!("");
+            for r in frame.var_stack.iter() {
+                println!("{}", r.repr(&state.store));
+            }
+            println!("{} {:?}", frame.program_counter, instruction);
+            */
             frame.program_counter += 1;
             instruction.clone()
         };
@@ -414,6 +420,11 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
                 let obj_ref = py_unwrap!(state, frame.locals.borrow().get(&name), ProcessorError::InvalidName(name)).clone();
                 frame.var_stack.push(obj_ref)
             }
+            Instruction::StoreFast(i) => {
+                let frame = call_stack.last_mut().unwrap();
+                let name = py_unwrap!(state, frame.code.varnames.get(i), ProcessorError::InvalidVarnameIndex).clone();
+                frame.locals.borrow_mut().insert(name, pop_stack!(state, frame.var_stack));
+            }
             Instruction::PopJumpIfFalse(target) => {
                 let frame = call_stack.last_mut().unwrap();
                 let obj = state.store.deref(&pop_stack!(state, frame.var_stack));
diff --git a/src/varstack.rs b/src/varstack.rs
@@ -21,6 +21,12 @@ impl<Item> VectorVarStack<Item> {
     }
 }
 
+impl<Item> VectorVarStack<Item> {
+    pub fn iter(&self) -> ::std::slice::Iter<Item> {
+        self.vector.iter()
+    }
+}
+
 impl<Item> VarStack for VectorVarStack<Item> where Item: Debug {
     type Item = Item;
 

Original file line number	Diff line number	Diff line change
`@@ -1 +1,2 @@`
`1`	`1`	`print('foo')`
	`2`	`+print('foo', 'bar')`
Original file line number	Diff line number	Diff line change
`@@ -21,6 +21,12 @@ impl<Item> VectorVarStack<Item> {`
`21`	`21`	`}`
`22`	`22`	`}`
`23`	`23`
	`24`	`+impl<Item> VectorVarStack<Item> {`
	`25`	`+ pub fn iter(&self) -> ::std::slice::Iter<Item> {`
	`26`	`+ self.vector.iter()`
	`27`	`+ }`
	`28`	`+}`
	`29`	`+`
`24`	`30`	`impl<Item> VarStack for VectorVarStack<Item> where Item: Debug {`
`25`	`31`	`type Item = Item;`
`26`	`32`