Implement CallFunctionKw.

progval · progval · commit b05e43a08621 · 2017-10-29T08:47:02.000+01:00
diff --git a/src/processor/instructions.rs b/src/processor/instructions.rs
@@ -69,7 +69,7 @@ pub enum Instruction {
     LoadFast(usize),
     StoreFast(usize),
     LoadGlobal(usize),
-    CallFunction(usize, usize), // nb_args, nb_kwargs
+    CallFunction(usize, bool), // nb_args + nb_kwargs, has_kwargs
     RaiseVarargs(usize),
     MakeFunction { has_defaults: bool, has_kwdefaults: bool, has_annotations: bool, has_closure: bool },
     BuildConstKeyMap(usize),
@@ -163,13 +163,14 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
             124 => Instruction::LoadFast(oparg),
             125 => Instruction::StoreFast(oparg),
             130 => Instruction::RaiseVarargs(oparg),
-            131 => Instruction::CallFunction(oparg, 0),
+            131 => Instruction::CallFunction(oparg, false),
             132 => Instruction::MakeFunction {
                 has_defaults: oparg & 0x01 != 0,
                 has_kwdefaults: oparg & 0x02 != 0,
                 has_annotations: oparg & 0x04 != 0,
                 has_closure: oparg & 0x08 != 0,
             },
+            141 => Instruction::CallFunction(oparg, true),
             156 => Instruction::BuildConstKeyMap(oparg),
             144 => panic!("The impossible happened."),
             _ => panic!(format!("Opcode not supported: {:?}", (opcode, oparg))),
diff --git a/src/processor/mod.rs b/src/processor/mod.rs
@@ -512,16 +512,27 @@ fn run_code<EP: EnvProxy>(state: &mut State<EP>, call_stack: &mut Vec<Frame>) ->
                 panic!("Bad RaiseVarargs argument") // TODO: Raise an exception instead
             }
 
-            Instruction::CallFunction(nb_args, nb_kwargs) => {
+            Instruction::CallFunction(nb_args, has_kwargs) => {
                 // See “Call constructs” at:
                 // http://security.coverity.com/blog/2014/Nov/understanding-python-bytecode.html
-                let kwargs;
+                let kwargs: Vec<(ObjectRef, ObjectRef)>;
                 let args;
                 let func;
                 {
                     let frame = call_stack.last_mut().unwrap();
-                    kwargs = py_unwrap!(state, frame.var_stack.pop_n_pairs(nb_kwargs), ProcessorError::StackTooSmall);
-                    args = py_unwrap!(state, frame.var_stack.pop_many(nb_args), ProcessorError::StackTooSmall);
+                    if has_kwargs {
+                        let ref obj = state.store.deref(&pop_stack!(state, frame.var_stack)).content;
+                        let names: Vec<ObjectRef> = match obj {
+                            &ObjectContent::Tuple(ref v) => v.into_iter().cloned().collect(),
+                            _ => panic!("Bad CallFunctionKw argument"),
+                        };
+                        let values: Vec<ObjectRef> = frame.var_stack.pop_many(names.len()).unwrap();
+                        kwargs = names.into_iter().zip(values).collect();
+                    }
+                    else {
+                        kwargs = Vec::new();
+                    }
+                    args = py_unwrap!(state, frame.var_stack.pop_many(nb_args - kwargs.len()), ProcessorError::StackTooSmall);
                     func = pop_stack!(state, frame.var_stack);
                 }
                 call_function(state, call_stack, &func, args, kwargs)
