.vscode/tasks.json

@@ -50,6 +50,18 @@
                 "kind": "build",
                 "isDefault": true
             }
+        },
+        {
+            "type": "shell",
+            "label": "cargo run --example tmp",
+            "command": "cargo run --example tmp",
+            "problemMatcher": [
+                "$rustc"
+            ],
+            "group": {
+                "kind": "build",
+                "isDefault": true
+            }
         }
     ]
 }
\ No newline at end of file

Cargo.lock

@@ -11,7 +11,7 @@ version = "0.1.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 
 [[package]]
-name = "first"
+name = "crust"
 version = "0.1.0"
 dependencies = [
  "nom 5.0.1 (registry+https://github.com/rust-lang/crates.io-index)",

Cargo.toml

 [package]
-name = "first"
+name = "crust"
 version = "0.1.0"
 authors = ["Per Lindgren <per.lindgren@ltu.se>"]
 edition = "2018"

README.md

@@ -20,6 +20,7 @@ Practical assigment:
   - Expressions (includig function calls)
   - Primitive types (boolean, i32) and their literals
   - Explicit types everywhere
+  - Explicit return(s)
 
 - Begin writing a parser for expressions in Rust using `nom` (parser combinator library)
 

examples/tmp.rs

+extern crate nom;
+
+
+use crust::parse::test;
+
+fn main() {
+    test("- -1 + + 1", - -1 + 1);  // rust does not allow + as a unary op (I do ;)
+    test("(-1-1)+(-1+3)", (-1 - 1) + (-1) + 3);
+    // just to check that right associative works (you don't need to implement pow)
+    test("2+3**2**3*5+1", 2 + 3i32.pow(2u32.pow(3)) * 5 + 1);
+    test("(12*2)/3-4", (12 * 2) / 3 - 4);
+    test("1*2+3", 1 * 2 + 3);
+    // just to check that we get a parse error
+    test("1*2+3+3*21-a12+2", 1 * 2 + 3 + 3 * 21 - 12 + 2);
+}
+
+

src/ast.rs

+// AST
+
+use nom_locate::LocatedSpan;
+
+pub type Span<'a> = LocatedSpan<&'a str>;
+
+#[derive(Debug, Clone, Copy, PartialEq)]
+pub enum Op {
+    Eq,
+    Neq,
+    And,
+    Or,
+    Add,
+    Sub,
+    Mul,
+    Div,
+    Pow,
+    Not,
+}
+
+type SpanOp<'a> = (Span<'a>, Op);
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Expr<'a> {
+    Num(i32),
+    Par(Box<SpanExpr<'a>>),
+    // Identifier
+    // Function application
+    BinOp(Op, Box<SpanExpr<'a>>, Box<SpanExpr<'a>>),
+    UnaryOp(Op, Box<SpanExpr<'a>>),
+}
+
+pub type SpanExpr<'a> = (Span<'a>, Expr<'a>);

src/lib.rs

+// lib
+
+pub mod ast;
+pub mod parse;

src/parse.rs

+extern crate nom;
+
+use std::iter::Peekable;
+use std::slice::Iter;
+
+use nom::{
+    branch::alt,
+    bytes::complete::tag,
+    character::complete::char,
+    character::complete::{digit1, multispace0},
+    combinator::{cut, map},
+    error::ParseError,
+    multi::many1,
+    sequence::{delimited, preceded},
+    IResult,
+};
+
+use crate::ast::{Expr, Op, Span, SpanExpr};
+
+pub fn parse_i32(i: Span) -> IResult<Span, (Span, i32)> {
+    map(digit1, |digit_str: Span| {
+        (digit_str, digit_str.fragment.parse::<i32>().unwrap())
+    })(i)
+}
+
+fn parse_op(i: Span) -> IResult<Span, (Span, Op)> {
+    alt((
+        map(tag("=="), |s| (s, Op::Eq)),
+        map(tag("!="), |s| (s, Op::Neq)),
+        map(tag("**"), |s| (s, Op::Pow)),
+        map(tag("&&"), |s| (s, Op::And)),
+        map(tag("||"), |s| (s, Op::Or)),
+        map(tag("+"), |s| (s, Op::Add)),
+        map(tag("-"), |s| (s, Op::Sub)),
+        map(tag("*"), |s| (s, Op::Mul)),
+        map(tag("/"), |s| (s, Op::Div)),
+        map(tag("!"), |s| (s, Op::Not)),
+    ))(i)
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub enum Token<'a> {
+    Num(i32),
+    Par(Vec<SpanToken<'a>>),
+    Op(Op),
+}
+
+type SpanToken<'a> = (Span<'a>, Token<'a>);
+
+fn parse_terminal(i: Span) -> IResult<Span, SpanToken> {
+    alt((
+        map(parse_i32, |(s, v)| (s, Token::Num(v))),
+        map(parse_par(parse_tokens), |(s, tokens)| {
+            (s, Token::Par(tokens))
+        }),
+    ))(i)
+}
+
+fn parse_token(i: Span) -> IResult<Span, SpanToken> {
+    preceded(
+        multispace0,
+        alt((map(parse_op, |(s, op)| (s, Token::Op(op))), parse_terminal)),
+    )(i)
+}
+
+// I think the outer span is wrong
+fn parse_tokens(i: Span) -> IResult<Span, (Span, Vec<SpanToken>)> {
+    map(many1(parse_token), |tokens| (i, tokens))(i)
+}
+
+fn compute_atom<'a>(t: &mut Peekable<Iter<SpanToken<'a>>>) -> SpanExpr<'a> {
+    match t.next() {
+        Some((s, Token::Num(i))) => (*s, Expr::Num(*i)),
+        Some((_, Token::Par(v))) => climb(&mut v.iter().peekable(), 0),
+        Some((s, Token::Op(op))) => (*s, Expr::UnaryOp(*op, Box::new(climb(t, 4)))), // assume highest precedence
+        _ => panic!("error in compute atom"),
+    }
+}
+
+fn climb<'a>(
+    t: &mut Peekable<Iter<SpanToken<'a>>>,
+    min_prec: u8,
+) -> SpanExpr<'a> {
+    let mut result: SpanExpr = compute_atom(t);
+
+    loop {
+        match t.peek() {
+            Some((s, Token::Op(op))) => {
+                let (prec, ass) = get_prec(op);
+                if prec < min_prec {
+                    break;
+                };
+                let next_prec = prec
+                    + match ass {
+                        Ass::Left => 1,
+                        _ => 0,
+                    };
+                t.next();
+                let rhs = climb(t, next_prec);
+                result = (*s, Expr::BinOp(*op, Box::new(result), Box::new(rhs)))
+            }
+            _ => {
+                break;
+            }
+        }
+    }
+    result
+}
+
+pub fn test(s: &str, v: i32) {
+    match parse_tokens(Span::new(s)) {
+        Ok((Span { fragment: "", .. }, (_, t))) => {
+            let mut t = t.iter().peekable();
+            println!("{:?}", &t);
+            let e = climb(&mut t, 0);
+            println!("{:?}", &e);
+            println!("eval {} {}", math_eval(&e), v);
+            assert_eq!(math_eval(&e), v);
+        }
+        Ok((s, t)) => println!(
+            "parse incomplete, \n parsed tokens \t{:?}, \n remaining \t{:?}",
+            t, s
+        ),
+        Err(err) => println!("{:?}", err),
+    }
+}
+
+// helpers
+fn parse_par<'a, O, F, E>(
+    inner: F,
+) -> impl Fn(Span<'a>) -> IResult<Span<'a>, O, E>
+where
+    F: Fn(Span<'a>) -> IResult<Span<'a>, O, E>,
+    E: ParseError<Span<'a>>,
+{
+    // delimited allows us to split up the input
+    // cut allwos us to consume the input (and prevent backtracking)
+    delimited(char('('), preceded(multispace0, inner), cut(char(')')))
+}
+
+fn math_eval(e: &SpanExpr) -> i32 {
+    match e.clone().1 {
+        Expr::Num(i) => i,
+        Expr::BinOp(op, l, r) => {
+            let lv = math_eval(&l);
+            let rv = math_eval(&r);
+            match op {
+                Op::Add => lv + rv,
+                Op::Sub => lv - rv,
+                Op::Mul => lv * rv,
+                Op::Div => lv / rv,
+                Op::Pow => lv.pow(rv as u32),
+                _ => unimplemented!(),
+            }
+        }
+        Expr::UnaryOp(op, e) => {
+            let e = math_eval(&e);
+            match op {
+                Op::Add => e,
+                Op::Sub => -e,
+                _ => unimplemented!(),
+            }
+        }
+        _ => unimplemented!(),
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq)]
+enum Ass {
+    Left,
+    Right,
+}
+
+fn get_prec(op: &Op) -> (u8, Ass) {
+    match op {
+        Op::Add => (1, Ass::Left),
+        Op::Sub => (1, Ass::Left),
+        Op::Mul => (2, Ass::Left),
+        Op::Div => (2, Ass::Left),
+        Op::Pow => (3, Ass::Right),
+        _ => unimplemented!(),
+    }
+}