Enum glsl::syntax::Expr

pub enum Expr {
    Variable(Identifier),
    IntConst(i32),
    UIntConst(u32),
    BoolConst(bool),
    FloatConst(f32),
    DoubleConst(f64),
    Unary(UnaryOp, Box<Expr>),
    Binary(BinaryOp, Box<Expr>, Box<Expr>),
    Ternary(Box<Expr>, Box<Expr>, Box<Expr>),
    Assignment(Box<Expr>, AssignmentOp, Box<Expr>),
    Bracket(Box<Expr>, ArraySpecifier),
    FunCall(FunIdentifier, Vec<Expr>),
    Dot(Box<Expr>, Identifier),
    PostInc(Box<Expr>),
    PostDec(Box<Expr>),
    Comma(Box<Expr>, Box<Expr>),
}

The most general form of an expression. As you can see if you read the variant list, in GLSL, an assignment is an expression. This is a bit silly but think of an assignment as a statement first then an expression which evaluates to what the statement “returns”.

An expression is either an assignment or a list (comma) of assignments.

Variants

Variable(Identifier)

A variable expression, using an identifier.

IntConst(i32)

Integral constant expression.

UIntConst(u32)

Unsigned integral constant expression.

BoolConst(bool)

Boolean constant expression.

FloatConst(f32)

Single precision floating expression.

DoubleConst(f64)

Double precision floating expression.

Unary(UnaryOp, Box<Expr>)

A unary expression, gathering a single expression and a unary operator.

Binary(BinaryOp, Box<Expr>, Box<Expr>)

A binary expression, gathering two expressions and a binary operator.

Ternary(Box<Expr>, Box<Expr>, Box<Expr>)

A ternary conditional expression, gathering three expressions.

Assignment(Box<Expr>, AssignmentOp, Box<Expr>)

An assignment is also an expression. Gathers an expression that defines what to assign to, an assignment operator and the value to associate with.

Bracket(Box<Expr>, ArraySpecifier)

Add an array specifier to an expression.

FunCall(FunIdentifier, Vec<Expr>)

A functional call. It has a function identifier and a list of expressions (arguments).

Dot(Box<Expr>, Identifier)

An expression associated with a field selection (struct).

PostInc(Box<Expr>)

Post-incrementation of an expression.

PostDec(Box<Expr>)

Post-decrementation of an expression.

Comma(Box<Expr>, Box<Expr>)

An expression that contains several, separated with comma.

Trait Implementations

impl Clone for Expr

fn clone(&self) -> Expr

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Expr

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

Formats the value using the given formatter.

impl From<Expr> for Condition

fn from(expr: Expr) -> Self

Converts to this type from the input type.

impl From<Expr> for Initializer

fn from(e: Expr) -> Self

Converts to this type from the input type.

impl From<bool> for Expr

fn from(x: bool) -> Expr

Converts to this type from the input type.

impl From<f32> for Expr

fn from(x: f32) -> Expr

Converts to this type from the input type.

impl From<f64> for Expr

fn from(x: f64) -> Expr

Converts to this type from the input type.

impl From<i32> for Expr

fn from(x: i32) -> Expr

Converts to this type from the input type.

impl From<u32> for Expr

fn from(x: u32) -> Expr

Converts to this type from the input type.

impl Host for Expr

fn visit<V>(&mut self, visitor: &mut V)where
    V: Visitor,

Visit an AST node.

impl Parse for Expr

fn parse<B>(source: B) -> ParseResult<Self>where
    B: AsRef<[u8]>,

Parse from a byte slice.

fn parse_str<S>(source: S) -> ParseResult<Self>where
    S: AsRef<str>,

Parse from a string.

impl PartialEq<Expr> for Expr

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl StructuralPartialEq for Expr