azur/bobbylisp
1
1
Fork 0
mirror of https://github.com/azur1s/bobbylisp.git synced 2024-10-16 02:37:40 -05:00
Code Issues Projects Releases Wiki Activity

parser again

Browse source
This commit is contained in:
azur 2023-03-01 02:23:45 +07:00
parent c82c3701ba
commit e6bbbdd5bd
8 changed files with 304 additions and 67 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

7
b.hlm
View file

@ -1,5 +1,4 @@
let foo : num = 1 in bar(foo) end
println((\x: num -> x + 35)(34));
16---1*3/-f(16)+8%-2;
lambda (foo : num) -> unknown = bar(foo)
let x : t = e1 in e2 end
a(b, c(d(e, f), g(h), i), j(k, l), m);

94
src/main.rs
View file

@ -2,54 +2,58 @@
pub mod parse;
pub mod trans;
use parse::parse::lex;
use parse::parse::{lex, parse};
use trans::low::{translate_expr, translate_js};
fn main() {
let input = r#"
println((\x: int -> x + 1)(1));
"#;
let path = std::env::args().nth(1).expect("No file path provided");
let src = std::fs::read_to_string(path).expect("Failed to read file");
let tokens = lex(input.to_owned());
println!("{:?}", tokens);
let (tokens, lex_errs) = lex(src.to_owned());
// use parse::past::*;
// use trans::ty::Type;
// use trans::low::*;
let parse_errs = if let Some(tokens) = tokens {
let (ast, parse_errs) = parse(tokens, src.len());
// let exprs = vec![
// PExpr::Call(Box::new(PExpr::Sym("println".to_string())), vec![
// PExpr::Str("Hello, world!".to_string()),
// ]),
// PExpr::Let {
// vars: vec![
// ("x".to_string(), Type::Num, PExpr::Num(1)),
// ],
// body: Box::new(PExpr::Sym("x".to_string())),
// },
// PExpr::Let {
// vars: vec![
// ("x".to_string(), Type::Num, PExpr::Num(34)),
// ("y".to_string(), Type::Num, PExpr::Num(35)),
// ],
// body: Box::new(PExpr::BinaryOp(
// PBinaryOp::Add,
// Box::new(PExpr::Sym("x".to_string())),
// Box::new(PExpr::Sym("y".to_string())),
// )),
// },
// ];
// let nexprs = exprs.into_iter().map(translate_expr).collect::<Vec<_>>();
// for expr in &nexprs {
// println!("{}", expr);
// }
// println!("──────────────────────────────────────────────────");
// let jsexprs = nexprs.into_iter().map(translate_js).collect::<Vec<_>>();
// for expr in &jsexprs {
// println!("{}", expr);
// }
if let Some(ast) = ast {
println!();
println!("\x1b[90m───SOURCE─────────────────────────────────────────\x1b[0m");
println!("{src}");
println!("\x1b[90m───PARSE TREE─────────────────────────────────────\x1b[0m");
for (e, _) in &ast {
println!("{}", {
let e = format!("{:?}", e);
if e.len() > 50 {
format!("{}...", &e[..47])
} else {
e
}
});
}
println!("\x1b[90m───INTERNAL AST───────────────────────────────────\x1b[0m");
let nexprs = ast.into_iter().map(|(e, _)| translate_expr(e)).collect::<Vec<_>>();
for expr in &nexprs {
println!("{}", expr);
}
println!("\x1b[90m───JS OUTPUT──────────────────────────────────────\x1b[0m");
let jsexprs = nexprs.into_iter().map(translate_js).collect::<Vec<_>>();
for expr in &jsexprs {
println!("{}", expr);
}
println!();
}
parse_errs
} else {
Vec::new()
};
if !lex_errs.is_empty() || !parse_errs.is_empty() {
lex_errs
.into_iter()
.map(|e| e.map(|c| c.to_string()))
.chain(parse_errs.into_iter().map(|e| e.map(|t| t.to_string())))
.for_each(|e| println!("{}", e));
}
}

206
src/parse/parse.rs
View file

@ -1,6 +1,8 @@
#![allow(clippy::type_complexity)]
use chumsky::{error, prelude::*, Stream};
use std::fmt::{Display, Formatter, Result as FmtResult};
use crate::trans::ty::Type;
use super::past::*;
#[derive(Clone, Copy, Debug, Eq, Hash, PartialEq)]
@ -174,6 +176,32 @@ pub fn symbol_parser() -> impl P<String> {
.labelled("symbol")
}
pub fn type_parser() -> impl P<Type> {
recursive(|ty| {
let litty = symbol_parser().map(|s| match s.as_str() {
"num" => Type::Num,
"str" => Type::Str,
"bool" => Type::Bool,
"?" => Type::Unknown,
_ => Type::Sym(s),
});
let fun = just(Token::Open(Delim::Paren))
.ignore_then(
ty.clone()
.separated_by(just(Token::Comma))
)
.then_ignore(just(Token::Close(Delim::Paren)))
.then_ignore(just(Token::Arrow))
.then(ty)
.map(|(args, ret)| Type::Fun(args, Box::new(ret)));
litty
.or(fun)
.labelled("type")
})
}
pub fn nested_parser<'a, T: 'a>(
parser: impl P<T> + 'a,
delim: Delim,
@ -202,3 +230,181 @@ pub fn nested_parser<'a, T: 'a>(
))
.boxed()
}
pub fn expr_parser() -> impl P<Spanned<PExpr>> {
recursive(|expr: Recursive<Token, Spanned<PExpr>, Simple<Token>>| {
let lit = literal_parser().map(PExpr::Lit);
let sym = symbol_parser().map(PExpr::Sym);
let vec = nested_parser(
expr.clone()
.separated_by(just(Token::Comma))
.allow_trailing()
.map(Some),
Delim::Brack,
|_| None,
)
.map(|xs| match xs {
Some(xs) => PExpr::Vec(xs),
None => PExpr::Vec(Vec::new()),
})
.labelled("vector");
// (e)
let paren_expr = just(Token::Open(Delim::Paren))
.ignore_then(expr.clone())
.then_ignore(just(Token::Close(Delim::Paren)))
.map(|e| e.0)
.labelled("parenthesized expression");
// \[sym : type]* -> expr
let lam = just(Token::Lambda)
.ignore_then(
(
symbol_parser()
.then_ignore(just(Token::Colon))
.then(type_parser())
)
.repeated()
)
.then_ignore(just(Token::Arrow))
.then(expr.clone())
.map(|(args, body)| PExpr::Lambda {
args,
body: Box::new(body),
})
.labelled("lambda");
let atom = lit
.or(sym)
.or(vec)
.or(paren_expr)
.or(lam)
.map_with_span(|e, s| (e, s))
.boxed()
.labelled("atom");
// e(e*)
let call = atom
.then(
nested_parser(
expr.clone()
.separated_by(just(Token::Comma))
.allow_trailing()
.map(Some),
Delim::Paren,
|_| None,
)
.or_not(),
)
.map_with_span(|(f, args), s| match args {
Some(Some(args)) => (PExpr::Call(Box::new(f), args), s),
Some(None) => (PExpr::Error, s),
None => f,
});
// op e
let unary = choice((
just(Token::Sub).to(PUnaryOp::Neg),
just(Token::Not).to(PUnaryOp::Not),
))
.map_with_span(|op, s| (op, s))
.repeated()
.then(call)
.foldr(|op, expr| {
let s = op.1.start()..expr.1.end();
(PExpr::Unary(op, Box::new(expr)), s)
})
.boxed();
let product = unary
.clone()
.then(
choice((
just(Token::Mul).to(PBinaryOp::Mul),
just(Token::Div).to(PBinaryOp::Div),
just(Token::Mod).to(PBinaryOp::Mod),
))
.map_with_span(|op, s| (op, s))
.then(unary)
.repeated(),
)
.foldl(|lhs, (op, rhs)| {
let s = lhs.1.start()..rhs.1.end();
(PExpr::Binary(op, Box::new(lhs), Box::new(rhs)), s)
})
.boxed();
let sum = product
.clone()
.then(
choice((
just(Token::Add).to(PBinaryOp::Add),
just(Token::Sub).to(PBinaryOp::Sub),
))
.map_with_span(|op, s| (op, s))
.then(product)
.repeated(),
)
.foldl(|lhs, (op, rhs)| {
let s = lhs.1.start()..rhs.1.end();
(PExpr::Binary(op, Box::new(lhs), Box::new(rhs)), s)
})
.boxed();
let comparison = sum
.clone()
.then(
choice((
just(Token::Eq).to(PBinaryOp::Eq),
just(Token::Neq).to(PBinaryOp::Neq),
just(Token::Lt).to(PBinaryOp::Lt),
just(Token::Lte).to(PBinaryOp::Lte),
just(Token::Gt).to(PBinaryOp::Gt),
just(Token::Gte).to(PBinaryOp::Gte),
))
.map_with_span(|op, s| (op, s))
.then(sum)
.repeated(),
)
.foldl(|lhs, (op, rhs)| {
let s = lhs.1.start()..rhs.1.end();
(PExpr::Binary(op, Box::new(lhs), Box::new(rhs)), s)
})
.boxed();
comparison
.clone()
.then(
choice((
just(Token::And).to(PBinaryOp::And),
just(Token::Or).to(PBinaryOp::Or),
))
.map_with_span(|op, s| (op, s))
.then(comparison)
.repeated(),
)
.foldl(|lhs, (op, rhs)| {
let s = lhs.1.start()..rhs.1.end();
(PExpr::Binary(op, Box::new(lhs), Box::new(rhs)), s)
})
.boxed()
})
}
pub fn exprs_parser() -> impl P<Vec<Spanned<PExpr>>> {
expr_parser()
.then_ignore(just(Token::Semicolon))
.repeated()
}
pub fn parse(
tokens: Vec<Spanned<Token>>,
len: usize,
) -> (Option<Vec<Spanned<PExpr>>>, Vec<Simple<Token>>) {
let (ast, parse_error) = exprs_parser()
.then_ignore(end())
.parse_recovery(Stream::from_iter(len..len + 1, tokens.into_iter()));
(ast, parse_error)
}

17
src/parse/past.rs
View file

@ -1,6 +1,8 @@
use std::fmt::{Display, Formatter, Result as FmtResult};
use crate::trans::ty::*;
use super::parse::Spanned;
#[derive(Clone, Debug)]
pub enum PUnaryOp {
Neg,
@ -20,21 +22,22 @@ pub enum PLiteral { Num(i64), Str(String), Bool(bool) }
/// Enum to represent a parsed expression
#[derive(Clone, Debug)]
pub enum PExpr {
Error,
Lit(PLiteral),
Sym(String),
Vec(Vec<Spanned<Self>>),
Vec(Vec<Self>),
Unary(Spanned<PUnaryOp>, Box<Spanned<Self>>),
Binary(Spanned<PBinaryOp>, Box<Spanned<Self>>, Box<Spanned<Self>>),
UnaryOp(PUnaryOp, Box<Self>),
BinaryOp(PBinaryOp, Box<Self>, Box<Self>),
Call(Box<Self>, Vec<Self>),
Call(Box<Spanned<Self>>, Vec<Spanned<Self>>),
Lambda {
args: Vec<(String, Type)>,
body: Box<Self>,
body: Box<Spanned<Self>>,
},
Let {
vars: Vec<(String, Type, Self)>,
body: Box<Self>,
}
},
}

13
src/trans/ast.rs
View file

@ -24,6 +24,7 @@ pub enum Literal {
pub enum Expr {
Lit(Literal),
Sym(String),
Vec(Vec<Self>),
UnaryOp(UnaryOp, Box<Self>),
BinaryOp(BinaryOp, Box<Self>, Box<Self>),
@ -44,9 +45,17 @@ impl Display for Expr {
Literal::Bool(b) => write!(f, "{}", b),
},
Expr::Sym(s) => write!(f, "{}", s),
Expr::Vec(v) => {
write!(f, "[")?;
for (i, e) in v.iter().enumerate() {
if i > 0 { write!(f, " ")?; }
write!(f, "{}", e)?;
}
write!(f, "]")
},
Expr::UnaryOp(op, e) => write!(f, "({:?} {})", op, e),
Expr::BinaryOp(op, e1, e2) => write!(f, "({:?} {} {})", op, e1, e2),
Expr::UnaryOp(op, e) => write!(f, "({} {})", format!("{:?}", op).to_lowercase(), e),
Expr::BinaryOp(op, e1, e2) => write!(f, "({} {} {})", format!("{:?}", op).to_lowercase(), e1, e2),
Expr::Call(c, args) => {
write!(f, "({}", c)?;

9
src/trans/js.rs
View file

@ -9,6 +9,7 @@ pub enum JSLiteral { Num(i64), Str(String), Bool(bool) }
pub enum JSExpr {
Lit(JSLiteral),
Sym(String),
Array(Vec<Self>),
Op(&'static str, Box<Self>, Option<Box<Self>>),
@ -29,6 +30,14 @@ impl Display for JSExpr {
JSLiteral::Bool(b) => write!(f, "{}", b),
},
JSExpr::Sym(s) => write!(f, "{}", s),
JSExpr::Array(v) => {
write!(f, "[")?;
for (i, e) in v.iter().enumerate() {
if i > 0 { write!(f, ", ")?; }
write!(f, "{}", e)?;
}
write!(f, "]")
},
JSExpr::Op(op, lhs, rhs) => {
match rhs {

29
src/trans/low.rs
View file

@ -6,18 +6,21 @@ use super::{
pub fn translate_expr(expr: PExpr) -> Expr {
match expr {
PExpr::Error => panic!("Error in expression!"),
PExpr::Lit(l) => Expr::Lit(match l {
PLiteral::Num(n) => Literal::Num(n),
PLiteral::Str(s) => Literal::Str(s),
PLiteral::Bool(b) => Literal::Bool(b),
}),
PExpr::Sym(s) => Expr::Sym(s),
PExpr::Vec(v) => Expr::Vec(v.into_iter().map(|e| translate_expr(e.0)).collect()),
PExpr::UnaryOp(op, e) => Expr::UnaryOp(match op {
PExpr::Unary(op, e) => Expr::UnaryOp(match op.0 {
PUnaryOp::Neg => UnaryOp::Neg,
PUnaryOp::Not => UnaryOp::Not,
}, Box::new(translate_expr(*e))),
PExpr::BinaryOp(op, e1, e2) => Expr::BinaryOp(
}, Box::new(translate_expr((*e).0))),
PExpr::Binary((op, _), e1, e2) => Expr::BinaryOp(
match op {
PBinaryOp::Add => BinaryOp::Add,
PBinaryOp::Sub => BinaryOp::Sub,
@ -36,33 +39,34 @@ pub fn translate_expr(expr: PExpr) -> Expr {
PBinaryOp::And => BinaryOp::And,
PBinaryOp::Or => BinaryOp::Or,
},
Box::new(translate_expr(*e1)),
Box::new(translate_expr(*e2)),
Box::new(translate_expr((*e1).0)),
Box::new(translate_expr((*e2).0)),
),
PExpr::Call(f, args) => Expr::Call(
Box::new(translate_expr(*f)),
args.into_iter().map(translate_expr).collect(),
Box::new(translate_expr((*f).0)),
args.into_iter().map(|a| translate_expr(a.0)).collect(),
),
PExpr::Lambda { args, body } => Expr::Lambda {
args,
body: Box::new(translate_expr(*body)),
body: Box::new(translate_expr((*body).0)),
},
PExpr::Let { vars, body } => {
let mut expr = *body; // The expression we're building up
let mut expr: Expr = translate_expr(*body); // The expression we're building up
for (name, ty, val) in vars.into_iter().rev() { // Reverse so we can build up the lambda
// e.g.: let x : t = e1 in e2 end => (lambda (x : t) = e2)(e1)
// Build up the lambda
expr = PExpr::Lambda {
expr = Expr::Lambda {
args: vec![(name, ty)],
body: Box::new(expr),
};
// Call the lambda with the value
expr = PExpr::Call(Box::new(expr), vec![val]);
let val = translate_expr(val);
expr = Expr::Call(Box::new(expr), vec![val]);
}
translate_expr(expr)
expr
}
}
}
@ -75,6 +79,7 @@ pub fn translate_js(expr: Expr) -> JSExpr {
Literal::Bool(b) => JSExpr::Lit(JSLiteral::Bool(b)),
},
Expr::Sym(s) => JSExpr::Sym(s),
Expr::Vec(v) => JSExpr::Array(v.into_iter().map(translate_js).collect()),
Expr::UnaryOp(op, e) => JSExpr::Op(match op {
UnaryOp::Neg => "-",

2
src/trans/ty.rs
View file

@ -3,6 +3,7 @@ use std::fmt::{Display, Formatter, Result as FmtResult};
#[derive(Clone, Debug)]
pub enum Type {
Num, Str, Bool,
Sym(String),
Fun(Vec<Self>, Box<Self>),
Unknown,
}
@ -13,6 +14,7 @@ impl Display for Type {
Type::Num => write!(f, "num"),
Type::Str => write!(f, "str"),
Type::Bool => write!(f, "bool"),
Type::Sym(s) => write!(f, "{}", s),
Type::Fun(args, ret) => {
write!(f, "(")?;
for (i, arg) in args.iter().enumerate() {