154 lines
4.1 KiB
Plaintext
154 lines
4.1 KiB
Plaintext
%start Body
|
|
|
|
%left '||'
|
|
%left '&&'
|
|
%left '<' '>' '<=' '>=' '==' '!='
|
|
%left '*' '/'
|
|
%left '+' '-'
|
|
|
|
%%
|
|
|
|
Body -> Result<Vec<Stmt>>:
|
|
Body 'EOL' Stmt {
|
|
flatten($1, $3)
|
|
}
|
|
| Body 'EOL' { $1 }
|
|
| Stmt { Ok(vec![$1?]) }
|
|
| { Ok(Vec::new()) }
|
|
;
|
|
|
|
Stmt -> Result<Stmt>:
|
|
Expr { Ok(Stmt::Expr($1?)) }
|
|
//| Assign { todo!() }
|
|
;
|
|
|
|
Expr -> Result<Expr>: BinExpr { $1 };
|
|
|
|
BinExpr -> Result<Expr>:
|
|
UnExpr '||' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Or, $3?)) }
|
|
| UnExpr '&&' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::And, $3?)) }
|
|
| UnExpr '<' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Lt, $3?)) }
|
|
| UnExpr '>' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Gt, $3?)) }
|
|
| UnExpr '<=' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Le, $3?)) }
|
|
| UnExpr '>=' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Ge, $3?)) }
|
|
| UnExpr '==' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Eq, $3?)) }
|
|
| UnExpr '!=' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Neq, $3?)) }
|
|
| UnExpr '*' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Times, $3?)) }
|
|
| UnExpr '/' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Div, $3?)) }
|
|
| UnExpr '+' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Plus, $3?)) }
|
|
| UnExpr '-' BinExpr { Ok(BinExpr::new_expr($1?, BinOp::Plus, $3?)) }
|
|
| UnExpr { $1 }
|
|
;
|
|
|
|
UnExpr -> Result<Expr>:
|
|
'+' UnExpr { Ok(UnExpr::new_expr(UnOp::Plus, $2?)) }
|
|
| '-' UnExpr { Ok(UnExpr::new_expr(UnOp::Minus, $2?)) }
|
|
| CallIndexExpr { $1 }
|
|
;
|
|
|
|
// TODO - add CallExpr and IndexExpr, allow them to nest
|
|
// - UnExpr will point to CallIndexExpr
|
|
// - Call/Index exprs are based on an AccessExpr
|
|
// - AccessExpr will retain ExprTrailing in between its items, but should end in a .ident
|
|
|
|
CallIndexExpr -> Result<Expr>:
|
|
IndexExpr { $1 }
|
|
| CallExpr { $1 }
|
|
| AccessExpr { $1 }
|
|
;
|
|
|
|
CallExpr -> Result<Expr>:
|
|
CallIndexExpr '(' FunArgs ')' {
|
|
Ok(CallExpr::new_expr($1?, $3?))
|
|
}
|
|
;
|
|
|
|
FunArgs -> Result<Vec<Expr>>:
|
|
FunArgsTail { $1 }
|
|
| { Ok(Vec::new()) }
|
|
;
|
|
|
|
FunArgsTail -> Result<Vec<Expr>>:
|
|
FunArgsTail ',' Expr { flatten($1, $3) }
|
|
| Expr { Ok(vec![$1?]) }
|
|
;
|
|
|
|
IndexExpr -> Result<Expr>:
|
|
CallIndexExpr '[' Expr ']' {
|
|
Ok(IndexExpr::new_expr($1?, $3?))
|
|
}
|
|
;
|
|
|
|
AccessExpr -> Result<Expr>:
|
|
AtomExpr { $1 }
|
|
| CallIndexExpr '.' Ident { Ok(AccessExpr::new_expr($1?, $3?)) }
|
|
;
|
|
|
|
AtomExpr -> Result<Expr>:
|
|
Atom { $1.map(Expr::Atom) }
|
|
| '(' Expr ')' { $2 }
|
|
;
|
|
|
|
Atom -> Result<Atom>:
|
|
Ident { Ok(Atom::Ident($1?)) }
|
|
| 'SYM' {
|
|
let v = $1.map_err(|_| ())?;
|
|
let sym = &$lexer.span_str(v.span())[1..];
|
|
Ok(Atom::Sym(sym.to_string()))
|
|
}
|
|
| 'NUM' {
|
|
let v = $1.map_err(|_| ())?;
|
|
let num_text = &$lexer.span_str(v.span());
|
|
Ok(Atom::Num(num_text.parse().unwrap()))
|
|
}
|
|
| 'STRING' {
|
|
let v = $1.map_err(|_| ())?;
|
|
let string = &$lexer.span_str(v.span())[1..];
|
|
Ok(Atom::String(parse_string(string)))
|
|
}
|
|
;
|
|
|
|
Ident -> Result<String>:
|
|
'IDENT' {
|
|
let v = $1.map_err(|_| ())?;
|
|
let ident = $lexer.span_str(v.span()).to_string();
|
|
Ok(ident)
|
|
}
|
|
;
|
|
|
|
%%
|
|
|
|
use crate::syn::ast::*;
|
|
|
|
type Result<T> = std::result::Result<T, ()>;
|
|
|
|
fn flatten<T>(head: Result<Vec<T>>, tail: Result<T>) -> Result<Vec<T>> {
|
|
let mut head = head?;
|
|
let tail = tail?;
|
|
head.push(tail);
|
|
Ok(head)
|
|
}
|
|
|
|
fn parse_string(input: &str) -> String {
|
|
let mut s = String::new();
|
|
let input = &input[1..input.bytes().len() - 1];
|
|
let mut chars = input.chars();
|
|
while let Some(c) = chars.next() {
|
|
if c == '\\' {
|
|
let next = chars.next().unwrap();
|
|
let c = match next {
|
|
'\\' => '\\',
|
|
'\'' => '\'',
|
|
'"' => '"',
|
|
'n' => '\n',
|
|
't' => '\t',
|
|
_ => unreachable!(),
|
|
};
|
|
s.push(c);
|
|
} else {
|
|
s.push(c);
|
|
}
|
|
}
|
|
s
|
|
}
|