class ComparisonOp(RegisterOp):
    """Comparison ops

    The result type will always be boolean.

    Support comparison between integer types and pointer types
    """
    error_kind = ERR_NEVER

    # S for signed and U for unsigned
    EQ = 100  # type: Final
    NEQ = 101  # type: Final
    SLT = 102  # type: Final
    SGT = 103  # type: Final
    SLE = 104  # type: Final
    SGE = 105  # type: Final
    ULT = 106  # type: Final
    UGT = 107  # type: Final
    ULE = 108  # type: Final
    UGE = 109  # type: Final

    op_str = {
        EQ: '==',
        NEQ: '!=',
        SLT: '<',
        SGT: '>',
        SLE: '<=',
        SGE: '>=',
        ULT: '<',
        UGT: '>',
        ULE: '<=',
        UGE: '>=',
    }  # type: Final

    def __init__(self, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
        super().__init__(line)
        self.type = bool_rprimitive
        self.lhs = lhs
        self.rhs = rhs
        self.op = op

    def sources(self) -> List[Value]:
        return [self.lhs, self.rhs]

    def to_str(self, env: Environment) -> str:
        if self.op in (self.SLT, self.SGT, self.SLE, self.SGE):
            sign_format = " :: signed"
        elif self.op in (self.ULT, self.UGT, self.ULE, self.UGE):
            sign_format = " :: unsigned"
        else:
            sign_format = ""
        return env.format('%r = %r %s %r%s', self, self.lhs,
                          self.op_str[self.op], self.rhs, sign_format)

    def accept(self, visitor: 'OpVisitor[T]') -> T:
        return visitor.visit_comparison_op(self)

class BinaryIntOp(RegisterOp):
    """Binary arithmetic and bitwise operations on integer types

    These ops are low-level and will be eventually generated to simple x op y form.
    The left and right values should be of low-level integer types that support those ops
    """
    error_kind = ERR_NEVER

    # arithmetic
    ADD = 0  # type: Final
    SUB = 1  # type: Final
    MUL = 2  # type: Final
    DIV = 3  # type: Final
    MOD = 4  # type: Final

    # bitwise
    AND = 200  # type: Final
    OR = 201  # type: Final
    XOR = 202  # type: Final
    LEFT_SHIFT = 203  # type: Final
    RIGHT_SHIFT = 204  # type: Final

    op_str = {
        ADD: '+',
        SUB: '-',
        MUL: '*',
        DIV: '/',
        MOD: '%',
        AND: '&',
        OR: '|',
        XOR: '^',
        LEFT_SHIFT: '<<',
        RIGHT_SHIFT: '>>',
    }  # type: Final

    def __init__(self, type: RType, lhs: Value, rhs: Value, op: int, line: int = -1) -> None:
        super().__init__(line)
        self.type = type
        self.lhs = lhs
        self.rhs = rhs
        self.op = op

    def sources(self) -> List[Value]:
        return [self.lhs, self.rhs]

    def to_str(self, env: Environment) -> str:
        return env.format('%r = %r %s %r', self, self.lhs,
                          self.op_str[self.op], self.rhs)

    def accept(self, visitor: 'OpVisitor[T]') -> T:
        return visitor.visit_binary_int_op(self)