Skip to content

wake.ir.yul.case_ module #

YulCase class #

Bases: YulAbc

Represents a single case in a YulSwitch statement.

Example

Lines 4-6, 7-9, and 10-12 in the following example:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
uint x = foo();
assembly {
    switch x
    case 0 {
        // ...
    }
    case 1 {
        // ...
    }
    default {
        // ...
    }
}
Source code in wake/ir/yul/case_.py 
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
class YulCase(YulAbc):
    """
    Represents a single case in a [YulSwitch][wake.ir.yul.switch.YulSwitch] statement.

    !!! example
        Lines 4-6, 7-9, and 10-12 in the following example:

        ```solidity linenums="1"
        uint x = foo();
        assembly {
            switch x
            case 0 {
                // ...
            }
            case 1 {
                // ...
            }
            default {
                // ...
            }
        }
        ```
    """

    _parent: weakref.ReferenceType[YulSwitch]
    _body: YulBlock
    _value: Union[Literal["default"], YulLiteral]

    def __init__(self, init: IrInitTuple, case_: SolcYulCase, parent: YulAbc):
        super().__init__(init, case_, parent)
        self._body = YulBlock(init, case_.body, self)
        if case_.value == "default":
            self._value = "default"
        else:
            self._value = YulLiteral(init, case_.value, self)

    def __iter__(self) -> Iterator[YulAbc]:
        yield self
        yield from self._body
        if self._value != "default":
            yield from self._value

    @property
    def parent(self) -> YulSwitch:
        """
        Returns:
            Parent IR node.
        """
        return super().parent

    @property
    def children(self) -> Iterator[Union[YulBlock, YulLiteral]]:
        """
        Yields:
            Direct children of this node.
        """
        yield self._body
        if self._value != "default":
            yield self._value

    @property
    def body(self) -> YulBlock:
        """
        Returns:
            Body of the case.
        """
        return self._body

    @property
    def value(self) -> Union[Literal["default"], YulLiteral]:
        """
        May be either a [YulLiteral][wake.ir.yul.literal.YulLiteral] or the string `default`.
        `default` is used for the default case when neither of the cases match. The default case
        is optional.

        Returns:
            Value that is compared to the switch expression.
        """
        return self._value

body property #

Returns:

Type Description
YulBlock

Body of the case.

children property #

Yields:

Type Description
Union[YulBlock, YulLiteral]

Direct children of this node.

parent property #

Returns:

Type Description
YulSwitch

Parent IR node.

value property #

May be either a YulLiteral or the string default. default is used for the default case when neither of the cases match. The default case is optional.

Returns:

Type Description
Union[Literal['default'], YulLiteral]

Value that is compared to the switch expression.