Enum BinaryOperator 

pub enum BinaryOperator {
    Mul,
    Div,
    SignedDiv,
    Mod,
    SignedMod,
    FloatDiv,
    FloatMul,
    Add,
    Sub,
    FloatAdd,
    FloatSub,
    LeftShift,
    RightShift,
    SignedRightShift,
    SignedLessThan,
    SignedGreaterThan,
    SignedLessEqual,
    SignedGreaterEqual,
    LessEqual,
    GreaterEqual,
    LessThan,
    GreaterThan,
    FloatLessEqual,
    FloatGreaterEqual,
    FloatLessThan,
    FloatGreaterThan,
    Equal,
    NotEqual,
    FloatEqual,
    FloatNotEqual,
    LogicalXor,
    LogicalAnd,
    LogicalOr,
    BitwiseXor,
    BitwiseOr,
    BitwiseAnd,
}

An infix operator in a p-code expression.

Unless a variant says otherwise, both operands and the result are the same width, and arithmetic wraps rather than trapping. The comparisons are the exception: they yield one byte holding 0 or 1, whatever their operands’ width. Self::is_comparison and its siblings classify a variant without having to match all thirty-six.

Variants

Mul

* — multiplication. The low half of the product, so the same for signed and unsigned operands.

Div

/ — unsigned division.

SignedDiv

s/ — signed division, truncating towards zero.

Mod

% — unsigned remainder.

SignedMod

s% — signed remainder, taking its sign from the dividend.

FloatDiv

f/ — floating-point division.

FloatMul

f* — floating-point multiplication.

Add

+ — addition. Two’s-complement, so the same for signed and unsigned operands; a carry or overflow flag is computed separately, with Builtin::Carry or Builtin::Sborrow.

Sub

- — subtraction, likewise sign-agnostic.

FloatAdd

f+ — floating-point addition.

FloatSub

f- — floating-point subtraction.

LeftShift

<< — left shift. Bits shifted off the top are discarded.

RightShift

>> — logical right shift, shifting in zeroes.

SignedRightShift

s>> — arithmetic right shift, shifting in copies of the sign bit.

SignedLessThan

s< — signed less-than.

SignedGreaterThan

s> — signed greater-than.

SignedLessEqual

s<= — signed less-than-or-equal.

SignedGreaterEqual

s>= — signed greater-than-or-equal.

LessEqual

<= — unsigned less-than-or-equal.

GreaterEqual

>= — unsigned greater-than-or-equal.

LessThan

< — unsigned less-than.

GreaterThan

> — unsigned greater-than.

FloatLessEqual

f<= — floating-point less-than-or-equal.

FloatGreaterEqual

f>= — floating-point greater-than-or-equal.

FloatLessThan

f< — floating-point less-than.

FloatGreaterThan

f> — floating-point greater-than.

Equal

== — bitwise equality. Sign-agnostic, since two’s-complement equality is bit equality.

NotEqual

!= — bitwise inequality.

FloatEqual

f== — floating-point equality, which is not bit equality: NaN compares unequal to itself, and the two zeroes compare equal.

FloatNotEqual

f!= — floating-point inequality.

LogicalXor

^^ — boolean exclusive-or. Operands are read as false when zero and true otherwise; the result is one byte.

LogicalAnd

&& — boolean and. One byte, and not short-circuiting: p-code has no control flow inside an expression, so both operands are evaluated.

LogicalOr

|| — boolean or, likewise one byte and not short-circuiting.

BitwiseXor

^ — bitwise exclusive-or, in the width of the operands.

BitwiseOr

| — bitwise or.

BitwiseAnd

& — bitwise and.

Implementations

impl BinaryOperator

pub fn is_comparison(self) -> bool

Does this operator yield a one-byte boolean rather than a value in the width of its operands?

pub fn is_shift(self) -> bool

Is this a shift, whose right operand is a distance rather than a value of the same width?

pub fn is_signed_comparison(self) -> bool

Is this one of the four comparisons that read their operands as two’s-complement signed integers?

pub fn is_float_comparison(self) -> bool

Is this one of the six comparisons that read their operands as floating-point?

pub fn is_float(self) -> bool

Does this operator read its operands as floating-point, whether it compares them or computes with them?

pub fn is_logical(self) -> bool

Is this a boolean connective (&&, ||, ^^) rather than a bitwise one? Both operands and the result are truth values, one byte wide.

pub fn is_signed_integer(self) -> bool

Does this operator read its operands as two’s-complement signed integers? Covers the signed comparisons plus s/, s% and s>>.

pub fn pretty_print(self) -> &'static str

Trait Implementations

impl Clone for BinaryOperator

fn clone(&self) -> BinaryOperator

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Copy for BinaryOperator

impl Debug for BinaryOperator

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for BinaryOperator

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for BinaryOperator

impl Hash for BinaryOperator

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BinaryOperator

fn eq(&self, other: &BinaryOperator) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl Serialize for BinaryOperator

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for BinaryOperator