progval
diff --git a/‎src/processor/instructions.rs‎
Lines changed: 16 additions & 4 deletions b/‎src/processor/instructions.rs‎
Lines changed: 16 additions & 4 deletions
diff --git a/‎src/processor/mod.rs‎
Lines changed: 6 additions & 0 deletions b/‎src/processor/mod.rs‎
Lines changed: 6 additions & 0 deletions
@@ -16,7 +16,7 @@ pub enum CmpOperator {
 }
 
 impl CmpOperator {
-    pub fn from_bytecode(n: u16) -> Self {
+    pub fn from_bytecode(n: u32) -> Self {
         match n {
             0 => CmpOperator::Lt,
             1 => CmpOperator::Leq,
@@ -52,6 +52,7 @@ pub enum Instruction {
     ForIter(usize),
     LoadConst(usize),
     LoadName(usize),
+    BuildTuple(usize),
     LoadAttr(usize),
     SetupLoop(usize),
     SetupExcept(usize),
@@ -70,12 +71,13 @@ pub enum Instruction {
 #[derive(Debug)]
 pub struct InstructionDecoder<I> where I: Iterator {
     bytestream: I,
+    arg_prefix: Option<u32>,
     pending_nops: u8, // Number of NOPs to be inserted after this instruction to match CPython's addresses (instructions have different sizes)
 }
 
 impl<I> InstructionDecoder<I> where I: Iterator {
     pub fn new(bytes: I) -> InstructionDecoder<I> {
-        InstructionDecoder { bytestream: bytes, pending_nops: 0, }
+        InstructionDecoder { bytestream: bytes, pending_nops: 0, arg_prefix: None, }
     }
 }
 
@@ -89,11 +91,19 @@ impl<'a, I> InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
             _ => panic!("End of stream in the middle of an instruction."),
         }
     }
-    fn read_argument(&mut self) -> u16 {
+    fn read_argument(&mut self) -> u32 {
         match (self.bytestream.next(), self.bytestream.next()) {
             (Some(b1), Some(b2)) => {
                 self.pending_nops += 2;
-                ((*b2 as u16) << 8) + (*b1 as u16)},
+                let arg = ((*b2 as u32) << 8) + (*b1 as u32);
+                if let Some(prefix) = self.arg_prefix {
+                    self.arg_prefix = None;
+                    (prefix << 16) + arg
+                }
+                else {
+                    arg
+                }
+            },
             _ => panic!("End of stream in the middle of an instruction."),
         }
     }
@@ -122,6 +132,7 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
                 93 => Instruction::ForIter(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),
                 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.
@@ -142,6 +153,7 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
                     let nb_annot = 0;
                     Instruction::MakeFunction(nb_pos as usize, nb_kw as usize, nb_annot as usize)
                 },
+                144 => { self.arg_prefix = Some(self.read_argument()); Instruction::Nop },
                 _ => panic!(format!("Opcode not supported: {}", opcode)),
             }
         })
 
@@ -390,6 +390,12 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
                     }
                 }
             }
+            Instruction::BuildTuple(size) => {
+                let frame = call_stack.last_mut().unwrap();
+                let mut content = py_unwrap!(state, frame.var_stack.pop_many(size), ProcessorError::StackTooSmall);
+                let tuple = state.primitive_objects.new_tuple(content);
+                frame.var_stack.push(state.store.allocate(tuple));
+            }
             Instruction::LoadAttr(i) => {
                 let (name, obj) = {
                     let frame = call_stack.last_mut().unwrap();
Original file line number	Diff line number	Diff line change
`@@ -390,6 +390,12 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->`
`390`	`390`	`}`
`391`	`391`	`}`
`392`	`392`	`}`
	`393`	`+ Instruction::BuildTuple(size) => {`
	`394`	`+ let frame = call_stack.last_mut().unwrap();`
	`395`	`+ let mut content = py_unwrap!(state, frame.var_stack.pop_many(size), ProcessorError::StackTooSmall);`
	`396`	`+ let tuple = state.primitive_objects.new_tuple(content);`
	`397`	`+ frame.var_stack.push(state.store.allocate(tuple));`
	`398`	`+ }`
`393`	`399`	`Instruction::LoadAttr(i) => {`
`394`	`400`	`let (name, obj) = {`
`395`	`401`	`let frame = call_stack.last_mut().unwrap();`