Enum rslua_march1917::ast::UnOp

pub enum UnOp {
    Minus,
    BNot,
    Not,
    Len,
    None,
}

Variants

Minus

BNot

Not

Len

None

Implementations

impl UnOp

pub fn from_token(token: TokenType) -> UnOp

Examples found in repository

src/parser.rs (line 414)

    fn get_unop(&self) -> UnOp {
        UnOp::from_token(self.current_token_type())
    }

pub fn priority(self) -> u8

Examples found in repository

src/parser.rs (line 436)

    fn subexpr(&mut self, limit: u8) -> ParseResult<Expr> {
        let mut left;
        let unop = self.get_unop();
        if unop != UnOp::None {
            self.next_and_skip_comment();
            let expr = Box::new(self.subexpr(unop.priority())?);
            left = Expr::UnExpr(UnExpr { op: unop, expr });
        } else {
            left = self.simpleexpr()?;
        }
        let mut binop = self.get_binop();
        while binop != BinOp::None && binop.priority().left > limit {
            self.skip_comment();
            self.next_and_skip_comment();
            let right = self.subexpr(binop.priority().right)?;
            left = Expr::BinExpr(BinExpr {
                left: Box::new(left),
                right: Box::new(right),
                op: binop,
            });
            binop = self.get_binop();
        }
        Ok(left)
    }

Trait Implementations

impl Clone for UnOp

fn clone(&self) -> UnOp

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for UnOp

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

Formats the value using the given formatter.

impl PartialEq<UnOp> for UnOp

fn eq(&self, other: &UnOp) -> 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 Copy for UnOp

impl StructuralPartialEq for UnOp