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 
 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
104
105
106
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

    @property
    def modifies_state(
        self,
    ) -> Set[Tuple[Union[ExpressionAbc, StatementAbc, YulAbc], ModifiesStateFlag]]:
        return self._body.modifies_state

body: YulBlock property #

Returns:

Type Description
YulBlock

Body of the case.

children: Iterator[Union[YulBlock, YulLiteral]] property #

Yields:

Type Description
Union[YulBlock, YulLiteral]

Direct children of this node.

parent: YulSwitch property #

Returns:

Type Description
YulSwitch

Parent IR node.

value: Union[Literal['default'], YulLiteral] 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.