Enum ExprKind 

pub enum ExprKind {
    Literal(LiteralExpr),
    FieldRef(FieldRefExpr),
    Sizeof(SizeofExpr),
    Alignof(AlignofExpr),
    Add(AddExpr),
    Sub(SubExpr),
    Mul(MulExpr),
    Div(DivExpr),
    Mod(ModExpr),
    Pow(PowExpr),
    BitAnd(BitAndExpr),
    BitOr(BitOrExpr),
    BitXor(BitXorExpr),
    LeftShift(LeftShiftExpr),
    RightShift(RightShiftExpr),
    BitNot(BitNotExpr),
    Neg(NegExpr),
    Not(NotExpr),
    Popcount(PopcountExpr),
    Eq(EqExpr),
    Ne(NeExpr),
    Lt(LtExpr),
    Gt(GtExpr),
    Le(LeExpr),
    Ge(GeExpr),
    And(AndExpr),
    Or(OrExpr),
    Xor(XorExpr),
}

Variants

Literal(LiteralExpr)

FieldRef(FieldRefExpr)

Sizeof(SizeofExpr)

Alignof(AlignofExpr)

Add(AddExpr)

Sub(SubExpr)

Mul(MulExpr)

Div(DivExpr)

Mod(ModExpr)

Pow(PowExpr)

BitAnd(BitAndExpr)

BitOr(BitOrExpr)

BitXor(BitXorExpr)

LeftShift(LeftShiftExpr)

RightShift(RightShiftExpr)

BitNot(BitNotExpr)

Neg(NegExpr)

Not(NotExpr)

Popcount(PopcountExpr)

Eq(EqExpr)

Ne(NeExpr)

Lt(LtExpr)

Gt(GtExpr)

Le(LeExpr)

Ge(GeExpr)

And(AndExpr)

Or(OrExpr)

Xor(XorExpr)

Implementations

impl ExprKind

pub fn try_evaluate_constant(&self) -> Option<u64>

Recursively evaluate this expression to a constant value if possible Returns None if the expression contains unresolvable references (like field refs)

pub fn to_c_string(&self) -> String

Format the expression as a C-style mathematical expression This format is compatible with C, Rust, and TypeScript for most operations

pub fn to_debug_string(&self) -> String

Generate a debug string representation of the expression

Trait Implementations

impl Clone for ExprKind

fn clone(&self) -> ExprKind

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl ConstantExpression for ExprKind

fn is_constant(&self) -> bool

impl Debug for ExprKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for ExprKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for ExprKind

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for ExprKind

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Eq for ExprKind

impl StructuralPartialEq for ExprKind