Enum rslua_march1917::ast::Expr

pub enum Expr {
    Nil,
    True,
    False,
    VarArg,
    Float(FloatType),
    Int(IntType),
    String(String),
    Name(String),
    ParenExpr(Box<Expr>),
    FuncBody(FuncBody),
    Table(Table),
    BinExpr(BinExpr),
    UnExpr(UnExpr),
    SuffixedExpr(SuffixedExpr),
}

Variants

Nil

True

False

VarArg

Float(FloatType)

Int(IntType)

String(String)

Name(String)

ParenExpr(Box<Expr>)

FuncBody(FuncBody)

Table(Table)

BinExpr(BinExpr)

UnExpr(UnExpr)

SuffixedExpr(SuffixedExpr)

Implementations

impl Expr

pub fn has_multi_ret(&self) -> bool

Examples found in repository

src/compiler.rs (line 230)

    fn adjust_assign(&mut self, num_left: usize, right_exprs: &Vec<Expr>) -> i32 {
        let extra = num_left as i32 - right_exprs.len() as i32;
        if let Some(last_expr) = right_exprs.last() {
            if last_expr.has_multi_ret() {
                // TODO : process multi return value
                todo!("process mult ret")
            }
        }

        if extra > 0 {
            let context = self.context();
            let from = context.get_reg_top();
            context.reserve_regs(extra as u32);
            context.proto.code_nil(from, extra as u32);
        }

        extra
    }

impl Expr

pub fn to_assignable(self) -> Assignable

Examples found in repository

src/parser.rs (line 377)

    fn exprstat(&mut self) -> ParseResult<Stat> {
        let expr = self.suffixedexpr()?;
        if self.test(TokenType::Assign) || self.test(TokenType::Comma) {
            Ok(Stat::AssignStat(self.assignment(expr.to_assignable())?))
        } else {
            Ok(Stat::CallStat(CallStat {
                call: expr.to_assignable(),
            }))
        }
    }

    // assignment -> ',' suffixedexp assignment
    // assignment -> '=' explist
    fn assignment(&mut self, first: Assignable) -> ParseResult<AssignStat> {
        let mut left: Vec<Assignable> = Vec::new();
        left.push(first);
        while self.test_next(TokenType::Comma) {
            left.push(self.suffixedexpr()?.to_assignable())
        }
        self.check_next(TokenType::Assign)?;
        self.skip_comment();
        let right = self.exprlist()?;
        Ok(AssignStat { left, right })
    }

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 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