diff --git a/src/compiler.cairo b/src/compiler.cairo index 1f480c6d..6444ac72 100644 --- a/src/compiler.cairo +++ b/src/compiler.cairo @@ -21,6 +21,21 @@ pub impl CompilerTraitImpl of CompilerTrait { opcodes.insert('OP_0', Opcode::OP_0); opcodes.insert('OP_1', Opcode::OP_1); opcodes.insert('OP_TRUE', Opcode::OP_TRUE); + opcodes.insert('OP_2', Opcode::OP_2); + opcodes.insert('OP_3', Opcode::OP_3); + opcodes.insert('OP_4', Opcode::OP_4); + opcodes.insert('OP_5', Opcode::OP_5); + opcodes.insert('OP_6', Opcode::OP_6); + opcodes.insert('OP_7', Opcode::OP_7); + opcodes.insert('OP_8', Opcode::OP_8); + opcodes.insert('OP_9', Opcode::OP_9); + opcodes.insert('OP_10', Opcode::OP_10); + opcodes.insert('OP_11', Opcode::OP_11); + opcodes.insert('OP_12', Opcode::OP_12); + opcodes.insert('OP_13', Opcode::OP_13); + opcodes.insert('OP_14', Opcode::OP_14); + opcodes.insert('OP_15', Opcode::OP_15); + opcodes.insert('OP_16', Opcode::OP_16); opcodes.insert('OP_DEPTH', Opcode::OP_DEPTH); opcodes.insert('OP_1ADD', Opcode::OP_1ADD); opcodes.insert('OP_ADD', Opcode::OP_ADD); diff --git a/src/opcodes/opcodes.cairo b/src/opcodes/opcodes.cairo index e5841ed9..6354b3e1 100644 --- a/src/opcodes/opcodes.cairo +++ b/src/opcodes/opcodes.cairo @@ -2,6 +2,21 @@ pub mod Opcode { pub const OP_0: u8 = 0; pub const OP_1: u8 = 81; pub const OP_TRUE: u8 = 81; + pub const OP_2: u8 = 82; + pub const OP_3: u8 = 83; + pub const OP_4: u8 = 84; + pub const OP_5: u8 = 85; + pub const OP_6: u8 = 86; + pub const OP_7: u8 = 87; + pub const OP_8: u8 = 88; + pub const OP_9: u8 = 89; + pub const OP_10: u8 = 90; + pub const OP_11: u8 = 91; + pub const OP_12: u8 = 92; + pub const OP_13: u8 = 93; + pub const OP_14: u8 = 94; + pub const OP_15: u8 = 95; + pub const OP_16: u8 = 96; pub const OP_DEPTH: u8 = 116; pub const OP_1ADD: u8 = 139; pub const OP_ADD: u8 = 147; @@ -93,21 +108,21 @@ pub mod Opcode { 79 => not_implemented(ref engine), 80 => not_implemented(ref engine), 81 => opcode_n(1, ref engine), - 82 => not_implemented(ref engine), - 83 => not_implemented(ref engine), - 84 => not_implemented(ref engine), - 85 => not_implemented(ref engine), - 86 => not_implemented(ref engine), - 87 => not_implemented(ref engine), - 88 => not_implemented(ref engine), - 89 => not_implemented(ref engine), - 90 => not_implemented(ref engine), - 91 => not_implemented(ref engine), - 92 => not_implemented(ref engine), - 93 => not_implemented(ref engine), - 94 => not_implemented(ref engine), - 95 => not_implemented(ref engine), - 96 => not_implemented(ref engine), + 82 => opcode_n(2, ref engine), + 83 => opcode_n(3, ref engine), + 84 => opcode_n(4, ref engine), + 85 => opcode_n(5, ref engine), + 86 => opcode_n(6, ref engine), + 87 => opcode_n(7, ref engine), + 88 => opcode_n(8, ref engine), + 89 => opcode_n(9, ref engine), + 90 => opcode_n(10, ref engine), + 91 => opcode_n(11, ref engine), + 92 => opcode_n(12, ref engine), + 93 => opcode_n(13, ref engine), + 94 => opcode_n(14, ref engine), + 95 => opcode_n(15, ref engine), + 96 => opcode_n(16, ref engine), 97 => not_implemented(ref engine), 98 => not_implemented(ref engine), 99 => not_implemented(ref engine), diff --git a/src/opcodes/tests/test_opcodes.cairo b/src/opcodes/tests/test_opcodes.cairo index 60e48b56..29f593f6 100644 --- a/src/opcodes/tests/test_opcodes.cairo +++ b/src/opcodes/tests/test_opcodes.cairo @@ -86,6 +86,21 @@ fn test_op_depth_empty_stack() { assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected for empty stack"); } +fn test_op_2() { + let program = "OP_2"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x02"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + #[test] fn test_op_depth_one_item() { let program = "OP_1 OP_DEPTH"; @@ -159,3 +174,227 @@ fn test_op_1add() { let expected_stack = array!["\0\0\0\0\0\0\0\x02"]; assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); } + +#[test] +fn test_op_3() { + let program = "OP_3"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x03"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_4() { + let program = "OP_4"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x04"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_5() { + let program = "OP_5"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x05"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_6() { + let program = "OP_6"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x06"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_7() { + let program = "OP_7"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x07"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_8() { + let program = "OP_8"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x08"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_9() { + let program = "OP_9"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x09"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_10() { + let program = "OP_10"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x0a"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_11() { + let program = "OP_11"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x0b"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_12() { + let program = "OP_12"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x0c"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_13() { + let program = "OP_13"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x0d"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_14() { + let program = "OP_14"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x0e"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_15() { + let program = "OP_15"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x0f"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +} + +#[test] +fn test_op_16() { + let program = "OP_16"; + let mut compiler = CompilerTraitImpl::new(); + let bytecode = compiler.compile(program); + let mut engine = EngineTraitImpl::new(bytecode); + let res = engine.step(); + assert!(res, "Execution of step failed"); + + let dstack = engine.get_dstack(); + assert_eq!(dstack.len(), 1, "Stack length is not 1"); + + let expected_stack = array!["\0\0\0\0\0\0\0\x10"]; + assert_eq!(dstack, expected_stack.span(), "Stack is not equal to expected"); +}