stuff
This commit is contained in:
+84
-78
@@ -2,46 +2,48 @@ use crate::parser::VecDspT;
|
||||
|
||||
pub use super::*;
|
||||
|
||||
pub type BoxExpr = Box<Parsed<Expr>>;
|
||||
|
||||
pub enum Expr {
|
||||
Block(Id<Body>),
|
||||
Group(Id<Expr>),
|
||||
Ident(Id<Ident>),
|
||||
Lit(Id<Lit>),
|
||||
Negate(Id<Expr>),
|
||||
Block(Parsed<Body>),
|
||||
Group(BoxExpr),
|
||||
Ident(Ident),
|
||||
Lit(Lit),
|
||||
Negate(BoxExpr),
|
||||
Call {
|
||||
target: Id<Expr>,
|
||||
args: Vec<Id<Expr>>,
|
||||
target: BoxExpr,
|
||||
args: Vec<Parsed<Expr>>,
|
||||
},
|
||||
Assign {
|
||||
target: Id<Expr>,
|
||||
val: Id<Expr>,
|
||||
target: BoxExpr,
|
||||
val: BoxExpr,
|
||||
},
|
||||
If {
|
||||
cond: Id<Expr>,
|
||||
body: Id<Expr>,
|
||||
cond: BoxExpr,
|
||||
body: BoxExpr,
|
||||
},
|
||||
Loop {
|
||||
body: Id<Expr>,
|
||||
body: BoxExpr,
|
||||
},
|
||||
While {
|
||||
cond: Id<Expr>,
|
||||
body: Id<Expr>,
|
||||
cond: BoxExpr,
|
||||
body: BoxExpr,
|
||||
},
|
||||
Fn(Id<Func>),
|
||||
Fn(Box<Parsed<Func>>),
|
||||
}
|
||||
|
||||
impl Parsable for Expr {
|
||||
impl Node for Expr {
|
||||
fn parse(ctx: &mut ParseCtx) -> Result<Self, CompilerMsg> {
|
||||
let mut res = Self::unit(ctx)?;
|
||||
while let Some(next) = ctx.peek() {
|
||||
res = match next {
|
||||
Token::Equal => {
|
||||
let target = ctx.push_adv(res);
|
||||
let val = ctx.parse_with(Self::unit)?;
|
||||
let target = ctx.push_adv(res).boxed();
|
||||
let val = ctx.parse_with(Self::unit)?.boxed();
|
||||
Expr::Assign { target, val }
|
||||
}
|
||||
Token::OpenParen => {
|
||||
let target = ctx.push_adv(res);
|
||||
let target = ctx.push_adv(res).boxed();
|
||||
let args = ctx.list(Token::Comma, Token::CloseParen)?;
|
||||
Expr::Call { target, args }
|
||||
}
|
||||
@@ -50,34 +52,71 @@ impl Parsable for Expr {
|
||||
}
|
||||
Ok(res)
|
||||
}
|
||||
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter, mut ctx: DisplayCtx) -> std::fmt::Result {
|
||||
match self {
|
||||
Self::Ident(ident) => ident.fmt(f, ctx),
|
||||
Self::Group(expr) => write!(f, "({})", expr.dsp(ctx)),
|
||||
Self::Fn(func) => func.fmt(f, ctx),
|
||||
Self::Lit(lit) => write!(f, "{}", lit),
|
||||
Self::Negate(expr) => {
|
||||
write!(f, "-{}", expr.dsp(ctx))
|
||||
}
|
||||
Self::Call { target, args } => {
|
||||
write!(f, "{}({})", target.dsp(ctx), args.dsp(ctx))
|
||||
}
|
||||
Self::Assign { target, val } => {
|
||||
write!(f, "{} = {}", target.dsp(ctx), val.dsp(ctx))
|
||||
}
|
||||
Self::If { cond, body } => {
|
||||
write!(f, "if {} {}", cond.dsp(ctx), body.dsp(ctx))
|
||||
}
|
||||
Self::While { cond, body } => {
|
||||
write!(f, "while {} {}", cond.dsp(ctx), body.dsp(ctx))
|
||||
}
|
||||
Self::Loop { body } => {
|
||||
write!(f, "loop {}", body.dsp(ctx))
|
||||
}
|
||||
Self::Block(body) => {
|
||||
write!(f, "{{")?;
|
||||
if !body.items.is_empty() {
|
||||
writeln!(f)?;
|
||||
ctx.indent += 3;
|
||||
body.fmt(f, ctx)?;
|
||||
}
|
||||
write!(f, "}}")?;
|
||||
Ok(())
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Expr {
|
||||
fn unit(ctx: &mut ParseCtx) -> Result<Self, CompilerMsg> {
|
||||
Ok(match ctx.expect_next()? {
|
||||
Token::Dash => Self::Negate(ctx.parse()?),
|
||||
Token::Ident(s) => Self::Ident(ctx.ident(s)),
|
||||
Token::Lit(l) => Self::Lit(ctx.lit(l)),
|
||||
Token::Fn => Self::Fn(ctx.parse()?),
|
||||
Token::Dash => Self::Negate(ctx.parse_box()?),
|
||||
Token::Ident(s) => Self::Ident(Ident(s)),
|
||||
Token::Lit(l) => Self::Lit(l),
|
||||
Token::Fn => Self::Fn(ctx.parse_box()?),
|
||||
Token::If => {
|
||||
let cond = ctx.parse()?;
|
||||
let body = cond_body(ctx)?;
|
||||
let cond = ctx.parse_box()?;
|
||||
let body = Self::body(ctx)?.boxed();
|
||||
Self::If { cond, body }
|
||||
}
|
||||
Token::While => {
|
||||
let cond = ctx.parse()?;
|
||||
let body = cond_body(ctx)?;
|
||||
let cond = ctx.parse_box()?;
|
||||
let body = Self::body(ctx)?.boxed();
|
||||
Self::While { cond, body }
|
||||
}
|
||||
Token::Loop => {
|
||||
let body = ctx.parse()?;
|
||||
let body = ctx.parse_box()?;
|
||||
Self::Loop { body }
|
||||
}
|
||||
Token::OpenParen => {
|
||||
if ctx.next_if(Token::CloseParen) {
|
||||
Self::Lit(ctx.push(Lit::Unit))
|
||||
Self::Lit(Lit::Unit)
|
||||
} else {
|
||||
let inner = ctx.parse()?;
|
||||
let inner = ctx.parse_box()?;
|
||||
ctx.expect(Token::CloseParen)?;
|
||||
Self::Group(inner)
|
||||
}
|
||||
@@ -105,67 +144,34 @@ impl Expr {
|
||||
ctx.expect(Token::CloseCurly)?;
|
||||
Ok(Expr::Block(id))
|
||||
}
|
||||
}
|
||||
|
||||
fn cond_body(ctx: &mut ParseCtx) -> Result<Id<Expr>, CompilerMsg> {
|
||||
if ctx.next_if(Token::Do) {
|
||||
ctx.parse()
|
||||
} else {
|
||||
ctx.parse_with(Expr::block)
|
||||
pub fn body(ctx: &mut ParseCtx) -> Result<Parsed<Expr>, CompilerMsg> {
|
||||
if ctx.next_if(Token::DoubleArrow) {
|
||||
ctx.parse()
|
||||
} else {
|
||||
ctx.parse_with(Expr::block)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Id<Expr> {
|
||||
pub fn ends_with_block(&self, nodes: &Nodes) -> bool {
|
||||
match nodes[self] {
|
||||
pub fn ends_with_block(&self) -> bool {
|
||||
match self {
|
||||
Expr::Block(..) => true,
|
||||
Expr::Loop { body }
|
||||
| Expr::While { body, .. }
|
||||
| Expr::If { body, .. }
|
||||
| Expr::Negate(body)
|
||||
| Expr::Assign { val: body, .. } => body.ends_with_block(nodes),
|
||||
Expr::Fn(f) => f.ends_with_block(nodes),
|
||||
| Expr::Assign { val: body, .. } => body.ends_with_block(),
|
||||
Expr::Fn(f) => f.ends_with_block(),
|
||||
_ => false,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl FmtNode for Expr {
|
||||
fn fmt(&self, f: &mut std::fmt::Formatter, mut ctx: DisplayCtx) -> std::fmt::Result {
|
||||
let do_ = |id: Id<Expr>| if ctx.nodes[id].is_block() { "" } else { "do " };
|
||||
match *self {
|
||||
Self::Ident(id) => id.fmt(f, ctx),
|
||||
Self::Group(id) => write!(f, "({})", id.dsp(ctx)),
|
||||
Self::Fn(id) => id.fmt(f, ctx),
|
||||
Self::Lit(id) => id.fmt(f, ctx),
|
||||
Self::Negate(id) => {
|
||||
write!(f, "-{}", id.dsp(ctx))
|
||||
}
|
||||
Self::Call { target, ref args } => {
|
||||
write!(f, "{}({})", target.dsp(ctx), args.dsp(ctx))
|
||||
}
|
||||
Self::Assign { target, val } => {
|
||||
write!(f, "{} = {}", target.dsp(ctx), val.dsp(ctx))
|
||||
}
|
||||
Self::If { cond, body } => {
|
||||
write!(f, "if {} {}{}", cond.dsp(ctx), do_(body), body.dsp(ctx))
|
||||
}
|
||||
Self::While { cond, body } => {
|
||||
write!(f, "while {} {}{}", cond.dsp(ctx), do_(body), body.dsp(ctx))
|
||||
}
|
||||
Self::Loop { body } => {
|
||||
write!(f, "loop {}", body.dsp(ctx))
|
||||
}
|
||||
Self::Block(body) => {
|
||||
write!(f, "{{")?;
|
||||
if !ctx.nodes[body].items.is_empty() {
|
||||
writeln!(f)?;
|
||||
ctx.indent += 3;
|
||||
body.fmt(f, ctx)?;
|
||||
}
|
||||
write!(f, "}}")?;
|
||||
Ok(())
|
||||
}
|
||||
impl Parsed<Expr> {
|
||||
pub fn fmt_body(&self, f: &mut std::fmt::Formatter, ctx: DisplayCtx) -> std::fmt::Result {
|
||||
match &self.node {
|
||||
Expr::Block(_) => self.node.fmt(f, ctx),
|
||||
_ => write!(f, "=> {}", self.dsp(ctx)),
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user