Add support for if. Fix instruction addresses.

Author: progval

functional_tests/if.py

@@ -0,0 +1,35 @@
+a = 5
+if a == 5:
+    print('5 == 5')
+
+print('---')
+
+if a == 5:
+    print('5 == 5')
+else:
+    print('5 != 5')
+
+print('---')
+
+if a == 6:
+    print('5 == 6')
+else:
+    print('5 != 6')
+
+print('---')
+
+if a == 5:
+    print('5 == 5')
+elif a == 6:
+    print('5 == 6')
+else:
+    print('5 != 5 and 5 != 6')
+
+print('---')
+
+if a == 6:
+    print('5 == 6')
+elif a == 5:
+    print('5 == 5')
+else:
+    print('5 != 5 and 5 != 6')

src/processor/instructions.rs

@@ -1,7 +1,43 @@
+#[derive(PartialEq)]
+#[derive(Debug)]
+pub enum CmpOperator {
+    Lt,  // Lower than
+    Leq, // Lower or equal
+    Eq,  // Equal
+    Neq, // Not equal
+    Gt,  // Greater than
+    Geq, // Greater or equal
+    In,
+    NotIn,
+    Is,
+    IsNot,
+    ExceptionMatch,
+}
+
+impl CmpOperator {
+    pub fn from_bytecode(n: u16) -> Self {
+        match n {
+            0 => CmpOperator::Lt,
+            1 => CmpOperator::Leq,
+            2 => CmpOperator::Eq,
+            3 => CmpOperator::Neq,
+            4 => CmpOperator::Gt,
+            5 => CmpOperator::Geq,
+            6 => CmpOperator::In,
+            7 => CmpOperator::NotIn,
+            8 => CmpOperator::Is,
+            9 => CmpOperator::IsNot,
+            10=> CmpOperator::ExceptionMatch,
+            _ => panic!("Invalid cmp operator code.")
+        }
+    }
+}
+
 #[derive(PartialEq)]
 #[derive(Debug)]
 pub enum Instruction {
     PopTop,
+    Nop,
     BinarySubscr,
     LoadBuildClass,
     ReturnValue,
@@ -10,6 +46,9 @@ pub enum Instruction {
     LoadName(usize),
     LoadAttr(usize),
     SetupLoop(usize),
+    CompareOp(CmpOperator),
+    JumpForward(usize),
+    PopJumpIfFalse(usize),
     LoadFast(usize),
     LoadGlobal(usize),
     CallFunction(usize, usize), // nb_args, nb_kwargs
@@ -19,24 +58,29 @@ pub enum Instruction {
 #[derive(Debug)]
 pub struct InstructionDecoder<I> where I: Iterator {
     bytestream: I,
+    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 }
+        InstructionDecoder { bytestream: bytes, pending_nops: 0, }
     }
 }
 
 impl<'a, I> InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
     fn read_byte(&mut self) -> u8 {
         match self.bytestream.next() {
-            Some(b) => *b,
+            Some(b) => {
+                self.pending_nops += 1;
+                *b
+            },
             _ => panic!("End of stream in the middle of an instruction."),
         }
     }
     fn read_argument(&mut self) -> u16 {
         match (self.bytestream.next(), self.bytestream.next()) {
             (Some(b1), Some(b2)) => {
+                self.pending_nops += 2;
                 ((*b2 as u16) << 8) + (*b1 as u16)},
             _ => panic!("End of stream in the middle of an instruction."),
         }
@@ -47,6 +91,10 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
     type Item = Instruction;
 
     fn next(&mut self) -> Option<Instruction> {
+        if self.pending_nops != 0 {
+            self.pending_nops -= 1;
+            return Some(Instruction::Nop)
+        };
         self.bytestream.next().map(|opcode| {
             match *opcode {
                 1 => Instruction::PopTop,
@@ -57,6 +105,9 @@ impl<'a, I> Iterator for InstructionDecoder<I> where I: Iterator<Item=&'a u8> {
                 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.
+                114 => Instruction::PopJumpIfFalse(self.read_argument() as usize),
                 116 => Instruction::LoadGlobal(self.read_argument() as usize),
                 120 => Instruction::SetupLoop(self.read_argument() as usize),
                 124 => Instruction::LoadFast(self.read_argument() as usize),

src/processor/mod.rs

@@ -3,7 +3,7 @@ pub mod instructions;
 use super::objects::{Code, ObjectStore, ObjectRef, ObjectContent, PrimitiveObjects, Object};
 use super::sandbox::EnvProxy;
 use super::stack::{Stack, VectorStack};
-use self::instructions::Instruction;
+use self::instructions::{CmpOperator, Instruction};
 use std::fmt;
 use std::collections::HashMap;
 use std::io::Read;
@@ -172,11 +172,13 @@ impl<EP: EnvProxy> Processor<EP> {
         let mut stacks = Stacks { var_stack: VectorStack::new(), loop_stack: VectorStack::new() };
         loop {
             let instruction = try!(instructions.get(program_counter).ok_or(ProcessorError::InvalidProgramCounter));
+            program_counter += 1;
             match *instruction {
                 Instruction::PopTop => {
                     pop_stack!(stacks.var_stack);
                     ()
                 },
+                Instruction::Nop => (),
                 Instruction::BinarySubscr => {
                     let index_ref = pop_stack!(stacks.var_stack);
                     let index = self.store.deref(&index_ref).content.clone();
@@ -207,13 +209,6 @@ impl<EP: EnvProxy> Processor<EP> {
                     let name = try!(code.names.get(i).ok_or(ProcessorError::InvalidNameIndex)).clone();
                     stacks.var_stack.push(try!(self.load_name(namespace, name)))
                 }
-                Instruction::SetupLoop(i) => {
-                    stacks.loop_stack.push(Loop { begin: program_counter, end: program_counter+i })
-                }
-                Instruction::LoadFast(i) => {
-                    let name = try!(code.varnames.get(i).ok_or(ProcessorError::InvalidVarnameIndex)).clone();
-                    stacks.var_stack.push(try!(self.load_name(namespace, name)))
-                }
                 Instruction::LoadAttr(i) => {
                     let obj = {
                         let obj_ref = try!(stacks.var_stack.pop().ok_or(ProcessorError::StackTooSmall));
@@ -222,6 +217,36 @@ impl<EP: EnvProxy> Processor<EP> {
                     let name = try!(code.names.get(i).ok_or(ProcessorError::InvalidNameIndex)).clone();
                     stacks.var_stack.push(try!(self.load_attr(&obj, name)))
                 },
+                Instruction::SetupLoop(i) => {
+                    stacks.loop_stack.push(Loop { begin: program_counter, end: program_counter+i })
+                }
+                Instruction::CompareOp(CmpOperator::Eq) => {
+                    // TODO: enhance this
+                    let obj1 = self.store.deref(&pop_stack!(stacks.var_stack));
+                    let obj2 = self.store.deref(&pop_stack!(stacks.var_stack));
+                    if obj1.name == obj2.name && obj1.content == obj2.content {
+                        stacks.var_stack.push(self.primitive_objects.true_obj.clone())
+                    }
+                    else {
+                        stacks.var_stack.push(self.primitive_objects.false_obj.clone())
+                    };
+                }
+                Instruction::JumpForward(delta) => {
+                    program_counter += delta
+                }
+                Instruction::LoadFast(i) => {
+                    let name = try!(code.varnames.get(i).ok_or(ProcessorError::InvalidVarnameIndex)).clone();
+                    stacks.var_stack.push(try!(self.load_name(namespace, name)))
+                }
+                Instruction::PopJumpIfFalse(target) => {
+                    let obj = self.store.deref(&pop_stack!(stacks.var_stack));
+                    match obj.content {
+                        ObjectContent::True => (),
+                        ObjectContent::False => program_counter = target,
+                        _ => unimplemented!(),
+                    }
+                }
+
                 Instruction::CallFunction(nb_args, nb_kwargs) => {
                     // See “Call constructs” at:
                     // http://security.coverity.com/blog/2014/Nov/understanding-python-bytecode.html
@@ -245,7 +270,6 @@ impl<EP: EnvProxy> Processor<EP> {
                 },
                 _ => panic!(format!("todo: instruction {:?}", *instruction)),
             }
-            program_counter += 1;
         };
     }