dranke/curlywas
1
0
Fork 0
mirror of https://github.com/exoticorn/curlywas.git synced 2026-01-20 11:46:43 +01:00
Code Issues Projects Releases Wiki Activity

warptunnel parses

Browse Source
This commit is contained in:
Dennis Ranke
2021-10-31 19:07:45 +01:00
parent 6f5d068bd6
commit 52e8210e09
1 changed files with 47 additions and 28 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
src/parser2.rs
View File

@@ -16,6 +16,7 @@ enum Token {
Loop, Loop,
BranchIf, BranchIf,
Defer, Defer,
As,
Ident(String), Ident(String),
Str(String), Str(String),
Int(i32), Int(i32),
@@ -37,6 +38,7 @@ impl fmt::Display for Token {
Token::Loop => write!(f, "loop"), Token::Loop => write!(f, "loop"),
Token::BranchIf => write!(f, "branch_if"), Token::BranchIf => write!(f, "branch_if"),
Token::Defer => write!(f, "defer"), Token::Defer => write!(f, "defer"),
Token::As => write!(f, "as"),
Token::Ident(s) => write!(f, "{}", s), Token::Ident(s) => write!(f, "{}", s),
Token::Str(s) => write!(f, "{:?}", s), Token::Str(s) => write!(f, "{:?}", s),
Token::Int(v) => write!(f, "{}", v), Token::Int(v) => write!(f, "{}", v),
@@ -186,6 +188,7 @@ fn lexer() -> impl Parser<char, Vec<(Token, Span)>, Error = Simple<char>> {
"loop" => Token::Loop, "loop" => Token::Loop,
"branch_if" => Token::BranchIf, "branch_if" => Token::BranchIf,
"defer" => Token::Defer, "defer" => Token::Defer,
"as" => Token::As,
_ => Token::Ident(ident), _ => Token::Ident(ident),
}); });
@@ -496,31 +499,47 @@ fn block_parser() -> impl Parser<Token, ast::Block, Error = Simple<Token>> + Clo
|span| ast::Expr::Error.with_span(span), |span| ast::Expr::Error.with_span(span),
)); ));
let op_cast = atom
.clone()
.then(
just(Token::As)
.ignore_then(type_parser())
.map_with_span(|type_, span| (type_, span))
.repeated(),
)
.foldl(|value, (type_, span)| {
ast::Expr::Cast {
value: Box::new(value),
type_,
}
.with_span(span)
});
let mem_size = just(Token::Ctrl('?')) let mem_size = just(Token::Ctrl('?'))
.to(ast::MemSize::Byte) .to(ast::MemSize::Byte)
.or(just(Token::Ctrl('!')).to(ast::MemSize::Word)); .or(just(Token::Ctrl('!')).to(ast::MemSize::Word));
let memory_op = atom let memory_op = op_cast
.clone() .clone()
.then( .then(
mem_size mem_size
.then(atom.clone()) .then(op_cast.clone())
.then_ignore(just(Token::Op("=".to_string()))) .then_ignore(just(Token::Op("=".to_string())))
.then(expression.clone()) .then(expression.clone())
.repeated(), .repeated(),
) )
.foldl(|left, ((size, right), value)| ast::Expression { .foldl(|left, ((size, right), value)| {
span: left.span.start..value.span.end, let span = left.span.start..value.span.end;
expr: ast::Expr::Poke { ast::Expr::Poke {
mem_location: ast::MemoryLocation { mem_location: ast::MemoryLocation {
span: left.span.start..right.span.end, span: span.clone(),
left: Box::new(left), left: Box::new(left),
size, size,
right: Box::new(right), right: Box::new(right),
}, },
value: Box::new(value), value: Box::new(value),
}, }
type_: None, .with_span(span)
}); });
let op_product = memory_op let op_product = memory_op
@@ -533,14 +552,14 @@ fn block_parser() -> impl Parser<Token, ast::Block, Error = Simple<Token>> + Clo
.then(memory_op.clone()) .then(memory_op.clone())
.repeated(), .repeated(),
) )
.foldl(|left, (op, right)| ast::Expression { .foldl(|left, (op, right)| {
span: left.span.start..right.span.end, let span = left.span.start..right.span.end;
expr: ast::Expr::BinOp { ast::Expr::BinOp {
op, op,
left: Box::new(left), left: Box::new(left),
right: Box::new(right), right: Box::new(right),
}, }
type_: None, .with_span(span)
}); });
let op_sum = op_product let op_sum = op_product
@@ -552,14 +571,14 @@ fn block_parser() -> impl Parser<Token, ast::Block, Error = Simple<Token>> + Clo
.then(op_product.clone()) .then(op_product.clone())
.repeated(), .repeated(),
) )
.foldl(|left, (op, right)| ast::Expression { .foldl(|left, (op, right)| {
span: left.span.start..right.span.end, let span = left.span.start..right.span.end;
expr: ast::Expr::BinOp { ast::Expr::BinOp {
op, op,
left: Box::new(left), left: Box::new(left),
right: Box::new(right), right: Box::new(right),
}, }
type_: None, .with_span(span)
}); });
let op_cmp = op_sum let op_cmp = op_sum
@@ -575,14 +594,14 @@ fn block_parser() -> impl Parser<Token, ast::Block, Error = Simple<Token>> + Clo
.then(op_sum.clone()) .then(op_sum.clone())
.repeated(), .repeated(),
) )
.foldl(|left, (op, right)| ast::Expression { .foldl(|left, (op, right)| {
span: left.span.start..right.span.end, let span = left.span.start..right.span.end;
expr: ast::Expr::BinOp { ast::Expr::BinOp {
op, op,
left: Box::new(left), left: Box::new(left),
right: Box::new(right), right: Box::new(right),
}, }
type_: None, .with_span(span)
}); });
let op_bit = op_cmp let op_bit = op_cmp
@@ -595,14 +614,14 @@ fn block_parser() -> impl Parser<Token, ast::Block, Error = Simple<Token>> + Clo
.then(op_cmp.clone()) .then(op_cmp.clone())
.repeated(), .repeated(),
) )
.foldl(|left, (op, right)| ast::Expression { .foldl(|left, (op, right)| {
span: left.span.start..right.span.end, let span = left.span.start..right.span.end;
expr: ast::Expr::BinOp { ast::Expr::BinOp {
op, op,
left: Box::new(left), left: Box::new(left),
right: Box::new(right), right: Box::new(right),
}, }
type_: None, .with_span(span)
}); });
op_bit op_bit