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

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

use cairo_lang_test_utils::test;
use indoc::indoc;
use itertools::join;
use pretty_assertions::assert_eq;

use crate::instructions::Instruction;
use crate::{casm, cell_ref};

#[test]
fn test_assert() {
    let x = 1;
    let y = cell_ref!([fp + 5]);
    let z = 5;

    let ctx = casm! {
        [fp - 5] = x, ap++;
        [fp - 5] = [ap + 1] + [fp - 5], ap++;
        [fp + 5] = [ap + 1] + 2;
        [ap + 5] = [[ap + 1] + 2];
        [ap + 5] = [[ap - 1] + 2];
        [ap + 5] = [[ap + 1] - 2];
        [ap + 5] = [[ap] + 2];
        [ap + 5] = [[ap + 1]];
        [ap + 5] = [[ap]];
        [ap] = [ap + 1] * [fp - 5];
        %{ memory[ap + 5] = segments.add() %}
        [fp - 5] = [ap + 1] * z;
        [fp - 5] = [ap + 1] * y;
        %{ memory[ap + 0] = memory[fp - 3] < 45 %}
        %{ memory[ap + 0] = 13 < memory[fp + 9] %}
        [fp - 5] = 1, ap++;
        [fp - 5] = [ap + 1];
        %{ memory[ap + 0] = memory[ap + 9] < memory[fp + 9] %}
        jmp 123 if [ap + 17] != 0;
        jmp rel [fp - 19] if [ap + 17] != 0;
        %{ (memory[ap + 0], memory[ap + 1]) = divmod(memory[ap + 9], memory[fp + 9]) %}
        %{ (memory[ap + 0], memory[ap + 1]) = divmod(50, memory[fp + 9]) %}
        %{ (memory[ap + 0], memory[ap + 1]) = divmod(memory[ap + 9], 2) %}
        call abs 5, ap++;
        call rel y, ap++;
        ret;
    };

    let code = join(ctx.instructions.iter().map(Instruction::to_string), "\n");
    assert_eq!(
        code,
        indoc! {"
            [fp + -5] = 1, ap++
            [fp + -5] = [ap + 1] + [fp + -5], ap++
            [fp + 5] = [ap + 1] + 2
            [ap + 5] = [[ap + 1] + 2]
            [ap + 5] = [[ap + -1] + 2]
            [ap + 5] = [[ap + 1] + -2]
            [ap + 5] = [[ap + 0] + 2]
            [ap + 5] = [[ap + 1] + 0]
            [ap + 5] = [[ap + 0] + 0]
            [ap + 0] = [ap + 1] * [fp + -5]
            %{ memory[ap + 5] = segments.add() %}
            [fp + -5] = [ap + 1] * 5
            [fp + -5] = [ap + 1] * [fp + 5]
            %{ memory[ap + 0] = memory[fp + -3] < 45 %}
            %{ memory[ap + 0] = 13 < memory[fp + 9] %}
            [fp + -5] = 1, ap++
            [fp + -5] = [ap + 1]
            %{ memory[ap + 0] = memory[ap + 9] < memory[fp + 9] %}
            jmp rel 123 if [ap + 17] != 0
            jmp rel [fp + -19] if [ap + 17] != 0
            %{ (memory[ap + 0], memory[ap + 1]) = divmod(memory[ap + 9], memory[fp + 9]) %}
            %{ (memory[ap + 0], memory[ap + 1]) = divmod(50, memory[fp + 9]) %}
            %{ (memory[ap + 0], memory[ap + 1]) = divmod(memory[ap + 9], 2) %}
            call abs 5, ap++
            call rel [fp + 5], ap++
            ret"}
    );
}