cairo-lang-casm 2.17.0

Cairo assembly encoding.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103

#[cfg(not(feature = "std"))]
use alloc::{string::ToString, vec};

use cairo_lang_test_utils::test;
use indoc::indoc;

use crate::cell_ref;
use crate::hints::CoreHint;
use crate::instructions::{
    AddApInstruction, AssertEqInstruction, CallInstruction, Instruction, InstructionBody,
    JnzInstruction, JumpInstruction, RetInstruction,
};
use crate::operand::{DerefOrImmediate, ResOperand};

#[test]
fn test_jump_format() {
    let abs_jmp_insn = Instruction::new(
        InstructionBody::Jump(JumpInstruction {
            target: DerefOrImmediate::from(3),
            relative: false,
        }),
        false,
    );

    assert_eq!(abs_jmp_insn.to_string(), "jmp abs 3");

    let rel_jmp_insn = Instruction::new(
        InstructionBody::Jump(JumpInstruction {
            target: DerefOrImmediate::from(-5),
            relative: true,
        }),
        true,
    );

    assert_eq!(rel_jmp_insn.to_string(), "jmp rel -5, ap++");
}

#[test]
fn test_call_format() {
    let abs_call_insn = CallInstruction { target: DerefOrImmediate::from(3), relative: false };

    assert_eq!(abs_call_insn.to_string(), "call abs 3");

    let rel_call_insn: InstructionBody = InstructionBody::Call(CallInstruction {
        target: DerefOrImmediate::from(-5),
        relative: true,
    });

    assert_eq!(rel_call_insn.to_string(), "call rel -5");
}

#[test]
fn test_jnz_format() {
    let jnz_insn =
        JnzInstruction { jump_offset: DerefOrImmediate::from(205), condition: cell_ref!([ap + 5]) };

    assert_eq!(jnz_insn.to_string(), "jmp rel 205 if [ap + 5] != 0");
}

#[test]
fn test_assert_eq_format() {
    let op1 = cell_ref!([ap + 5]);
    let op2 = ResOperand::from(205);

    let insn = AssertEqInstruction { a: op1, b: op2 };
    assert_eq!(insn.to_string(), "[ap + 5] = 205");
}

#[test]
fn test_ret_format() {
    let insn = RetInstruction {};
    assert_eq!(insn.to_string(), "ret");
}

#[test]
fn test_add_ap_format() {
    let operand = ResOperand::from(205);

    let addap_insn: InstructionBody = InstructionBody::AddAp(AddApInstruction { operand });

    assert_eq!(addap_insn.to_string(), "ap += 205");
}

#[test]
fn test_instruction_with_hint() {
    let dst = cell_ref!([ap + 5]);
    let abs_jmp_insn = Instruction {
        body: InstructionBody::Jump(JumpInstruction {
            target: DerefOrImmediate::from(3),
            relative: false,
        }),
        inc_ap: false,
        hints: vec![CoreHint::AllocSegment { dst }.into()],
    };

    assert_eq!(
        abs_jmp_insn.to_string(),
        indoc! {"
            %{ memory[ap + 5] = segments.add() %}
            jmp abs 3"
        }
    );
}