Compare revisions

                "kind": "build",

                "kind": "build",

                "isDefault": true

                "isDefault": true

            }

            }

        },

        {

            "type": "shell",

            "label": "cargo run --example crust",

            "command": "cargo run --example crust",

            "problemMatcher": [

                "$rustc"

            ],

            "group": {

                "kind": "build",

                "isDefault": true

            }

        }

        }

    ]

    ]

}

}

 No newline at end of file

[dependencies]

[dependencies]

nom = "5.0.1"

nom = "5.0.1"

nom_locate = "1.0.0"

nom_locate = "1.0.0"

inkwell = { git = "https://github.com/TheDan64/inkwell", branch = "llvm8-0" }

- [Your repo](#your-repo)

- [Your syntax](#your-syntax)

- [Your semantics](#your-semantics)

- [Your type checker](#your-type-checker)

- [Your borrrow checker](#your-borrrow-checker)

- [Your LLVM backend](#your-llvm-backend)

- [Overal course goals and learning outcomes.](#overal-course-goals-and-learning-outcomes)

## Your repo

- Link to your repo here: https://github.com/dynematic/d7050e

## Your syntax

- Give an as complete as possible EBNF grammar for your language

- Give an example that showcases all rules of your EBNF. The program should "do" something as used in the next excercise.

- If you support pointers, make sure your example covers pointers as well.

- Compare your solution to the requirements (as stated in the README.md). What are your contributions to the implementation.

Program

```ebnf

    : FunctionDec+

    ;

```

FunctionDec

```ebnf

    : "fn" Id "(" [ "," ], Params ")" "->" Type "{" Statement "}"

    | "fn" Id "(" [ "," ], Params ")" "{" Statement "}"

    ;

```

Params

```ebnf

    : "Id" ":" Type

    ;

```

Statement

```ebnf

    : "let" Id ":" Type AssignOp Expr ";"

    | "if" Log "{" Statement "}"

    | "while" Log "{" Statement "}"

    | "return" Expr ";"

    | Expr ";"

    ;

```

LogOp

```ebnf

    : "&&"

    | "||"

    | "!"

    ;

```

CondOp

```ebnf

    : ">"

    | "<"

    | "=="

    | "!="

    ;

```

AssignOp

```ebnf

    : "="

    | "+="

    | "-="

    | "/="

    | "*="

    ;

```

SumOp

```ebnf

    : "+"

    | "-"

    ;

```

FactorOp

```ebnf

    : "*"

    | "/"

    ;

```

Type

```ebnf

    : "i32"

    | "bool"

    ;

```

Term

```ebnf

    : Num

    | Id

    | Bool

    | Function

    | "(" Expr ")"

    ;

```

Num

```ebnf

    : [ "-" ], Digit

    ;

```

Id

```ebnf

    : Letter , { Letter | Digit }, - White_space

```

Bool

```ebnf

    : "true"

    | "false"

    ;

```

Function

```ebnf

    : Id "(" [ "," ], Expr ")"

    ;

```

Letter

```ebnf

    : "A" | "B" | "C" | "D" | "E" | "F" | "G"

    | "H" | "I" | "J" | "K" | "L" | "M" | "N"

    | "O" | "P" | "Q" | "R" | "S" | "T" | "U"

    | "V" | "W" | "X" | "Y" | "Z" | "a" | "b"

    | "c" | "d" | "e" | "f" | "g" | "h" | "i"

    | "j" | "k" | "l" | "m" | "n" | "o" | "p"

    | "q" | "r" | "s" | "t" | "u" | "v" | "w"

    | "x" | "y" | "z" 

    ;

```

Digit

```ebnf

    : "0" | "1" | "2" | "3" | "4" | "5" | "6" | "7" | "8" | "9" 

    ;

```

White_space

```ebnf

    : ? White_space characters ? 

    ;

```

Showcase

```rust

fn test_i32(b: i32, c: i32) -> i32 {

    let a : i32 = 10 + 2 * 3;

    a = -1 - (1 - 1);

    return a + b;

}

fn test_bool(b: bool) -> bool {

    if b && true || false {

        let a : i32 = test_i32(1, 999);

        while (a < 5) {

            a = a + 1;

        }

        return a;

    }

}

fn main() {

    test_bool(true);

}

```

Above descirbed EBNF and showcase defines a minimal subset of Rust, including

- Function declaration, with excplicit return type either void (NONE) or primitive type

- Primitive types are i32 and boolean

- let, assignment, if, while and return statements with explicit types

- Operands are divided into logical, conditionl and arithmetic operands with precedence

- Parantesized precedence and FactorOp has precedence over SumOp

- Assignment operands are seperated from above mentioned operands

- Location information for Error is not implemented

- Error recovery is not implemented

For furture development

- Rethink how assignment operands are handled in grammar

- Add if else statement

- Add support for String in Term

- Error handling, location information and recovery

## Your semantics

- Give an as complete as possible Structural Operetional Semantics (SOS) for your language

- Explain (in text) what an interpretation of your example should produce, do that by dry running your given example step by step. Relate back to the SOS rules. You may skip repetions to avoid cluttering.

- Compare your solution to the requirements (as stated in the README.md). What are your contributions to the implementation.

Structural Operational Semantics (SOS)

Symbolx: 

- σ, state

- σ', derived state

- ⇓, evaluates

- c, command

- x, variable

- e, expression

- b, boolean expression

Command sequence

$\frac{<c1,σ> ⇓ σ' <c2,σ'> ⇓ σ''}{<c1;c2,σ> ⇓ σ''}$

Arithmetic

$\frac{<e1,σ> ⇓ n1 <e2, σ> ⇓ n2}{<e1 + e2, σ> ⇓ n1 plus n2}$

If true

$\frac{<b, σ> ⇓ true <c1, σ> ⇓ σ'}{<if b then c1> ⇓ σ}$

If false

$\frac{<b, σ> ⇓ false <c1, σ> ⇓ σ'}{<if b then c1> ⇓ σ}$

## Your type checker

- Give an as complete as possible set of Type Checking Rules for your language (those rules look very much like the SOS rules, but over types not values).

- Demonstrate each "type rule" by an example.

- Compare your solution to the requirements (as stated in the README.md). What are your contributions to the implementation.

## Your borrrow checker

- Give a specification for well versus ill formed borrows. (What are the rules the borrow checker should check).

- Demonstrate the cases of ill formed borrows that your borrow checker is able to detect and reject.

- Compare your solution to the requirements (as stated in the README.md). What are your contributions to the implementation.

## Your LLVM backend

- Let your backend produces LLVM-IR for your example program.

- Describe where and why you introduced allocations and phi nodes.

- If you have added optimization passes and/or attributed your code for better optimization (using e.g., `noalias`).

- Compare your solution to the requirements (as stated in the README.md). What are your contributions to the implementation.

## Overal course goals and learning outcomes.

Comment on the alignment of the concrete course goals (taken from the course description) to the theory presented, work You have done and knowledge You have gained. (I have put some comments in [...]).

- Lexical analysis, syntax analysis, and translation into abstract syntax.

- Regular expressions and grammars, context-free languages and grammars, lexer and parser generators. [Nom is lexer/parser library (and replaces the need for a generator, while lalr-pop is a classical parser generator)]

- Identifier handling and symbol table organization. Type-checking, logical inference systems. [SOS is a logical inference system]

- Intermediate representations and transformations for different languages. [LLVM is a cross language compiler infrastructure]

- Code optimization and register allocation. Machine code generation for common architectures. [LLVM is a cross target compiler infrastructure, doing the "dirty work" of optimazation/register allocation leveraging the SSA form of the LLVM-IR]

Comment on additional things that you have experienced and learned throughout the course.

Fundamental theories about computation and different models of computation. Construction of compilers. Lexical analysis, syntax analysis, and translation into abstract syntax. Regular expressions and grammars, context-free languages and grammars, lexer and parser generators. Identifier handling and symbol table organization. Type-checking, logical inference systems. Intermediate representations and transformations for different languages. Code optimization and register allocation. Machine code generation for common architectures.

Fundamental theories about computation and different models of computation. Construction of compilers. Lexical analysis, syntax analysis, and translation into abstract syntax. Regular expressions and grammars, context-free languages and grammars, lexer and parser generators. Identifier handling and symbol table organization. Type-checking, logical inference systems. Intermediate representations and transformations for different languages. Code optimization and register allocation. Machine code generation for common architectures.

In the course you will learn and develop your skills through hands on implementation work building your own complier from scratch. In this way theoretical aspects such as formal grammars, Structural Operational Semantics (SOS), and type rule formalisations becomes tangible. We will even touch upon memory safety and how guarantees can be achieved through static (compilet time) borrow checking. Compiler backend (code optimization etc.) will be discussed in context of LLVM, which you will optionally interface as a library for code generation.

In the course you will learn and develop your skills through hands on implementation work building your own complier from scratch. In this way theoretical aspects such as formal grammars, Structural Operational Semantics (SOS), and type rule formalisations becomes tangible. We will even touch upon memory safety and how guarantees can be achieved through static (compile time) borrow checking. Compiler backend (code optimization etc.) will be discussed in context of LLVM, which you will optionally interface as a library for code generation.

## Draft outline

## Draft outline

}

}

// helpers

// helpers

fn parse_par<'a, O, F, E>(

fn parse_par<'a, O, F, E>(inner: F) -> impl Fn(&'a str) -> IResult<&'a str, O, E>

    inner: F,

) -> impl Fn(&'a str) -> IResult<&'a str, O, E>

where

where

    F: Fn(&'a str) -> IResult<&'a str, O, E>,

    F: Fn(&'a str) -> IResult<&'a str, O, E>,

    E: ParseError<&'a str>,

    E: ParseError<&'a str>,

extern crate inkwell;

use inkwell::builder::Builder;

use inkwell::context::Context;

use inkwell::execution_engine::{ExecutionEngine, JitFunction};

use inkwell::module::Module;

use inkwell::OptimizationLevel;

use std::error::Error;

/// Convenience type alias for the `sum` function.

///

/// Calling this is innately `unsafe` because there's no guarantee it doesn't

/// do `unsafe` operations internally.

type SumFunc = unsafe extern "C" fn(u64, u64, u64) -> u64;

fn jit_compile_sum(

    context: &Context,

    module: &Module,

    builder: &Builder,

    execution_engine: &ExecutionEngine,

) -> Option<JitFunction<SumFunc>> {

    let i64_type = context.i64_type();

    let fn_type = i64_type

        .fn_type(&[i64_type.into(), i64_type.into(), i64_type.into()], false);

    let function = module.add_function("sum", fn_type, None);

    let basic_block = context.append_basic_block(&function, "entry");

    builder.position_at_end(&basic_block);

    let x = function.get_nth_param(0)?.into_int_value();

    let y = function.get_nth_param(1)?.into_int_value();

    let z = function.get_nth_param(2)?.into_int_value();

    let sum = builder.build_int_add(x, y, "sum");

    let sum = builder.build_int_add(sum, z, "sum");

    builder.build_return(Some(&sum));

    unsafe { execution_engine.get_function("sum").ok() }

}

fn main() -> Result<(), Box<dyn Error>> {

    let context = Context::create();

    let module = context.create_module("sum");

    let builder = context.create_builder();

    let execution_engine =

        module.create_jit_execution_engine(OptimizationLevel::None)?;

    let sum = jit_compile_sum(&context, &module, &builder, &execution_engine)

        .ok_or("Unable to JIT compile `sum`")?;

    let x = 1u64;

    let y = 2u64;

    let z = 3u64;

    unsafe {

        println!("{} + {} + {} = {}", x, y, z, sum.call(x, y, z));

        assert_eq!(sum.call(x, y, z), x + y + z);

    }

    Ok(())

}

    );

    );

}

}

fn main() {

fn main() {

    let (a, b) = parse_expr(Span::new("1")).unwrap();

    let (a, b) = parse_expr(Span::new("1")).unwrap();

    println!("{:?}", parse_expr(Span::new("1")));

    println!("{:?}", parse_expr(Span::new("1")));

    let (i, digits) = digit1(i)?;

    let (i, digits) = digit1(i)?;

    match digits.fragment.parse() {

    match digits.fragment.parse() {

        Ok(int) => Ok((i, (digits, Expr::Num(int)))),

        Ok(int) => Ok((i, (digits, Expr::Num(int)))),

        Err(e) => Err(Err::Failure(Error(i, Some(digits), ErrorKind::ParseIntError(e)))),

        Err(e) => Err(Err::Failure(Error(

            i,

            Some(digits),

            ErrorKind::ParseIntError(e),

        ))),

    }

    }

}

}

extern crate nom;

use crust::{

    ast::Span,

    interpreter::eval_expr,

    parse::{parse_assign, parse_expr, parse_prog},

};

fn test(s: &str, v: i32) {

    match parse_expr(Span::new(s)) {

        Ok((Span { fragment: "", .. }, e)) => {

            println!("{:?}", &e);

            println!("eval {} {}", eval_expr(&e), v);

            assert_eq!(eval_expr(&e), v);

        }

        Ok((s, t)) => println!(

            "parse incomplete, \n parsed tokens \t{:?}, \n remaining \t{:?}",

            t, s

        ),

        Err(err) => println!("{:?}", err),

    }

}

use crust::parse::test;

fn test_expr() {

    // 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);

    test("1 + (1 - 2)", 1 + (1 - 2));

}

fn main() {

fn main() {

    test("- -1 + + 1", - -1 + 1);  // rust does not allow + as a unary op (I do ;)

    // println!("{:?}", parse_assign(Span::new("3 = a(1, 2+3)")));

    test("(-1-1)+(-1+3)", (-1 - 1) + (-1) + 3);

    println!(

    // 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);

        parse_prog(Span::new(

    test("(12*2)/3-4", (12 * 2) / 3 - 4);

            "

    test("1*2+3", 1 * 2 + 3);

      fn main() { let a:i32 = 1} "

    // just to check that we get a parse error

        ))

    test("1*2+3+3*21-a12+2", 1 * 2 + 3 + 3 * 21 - 12 + 2);

    );

}

}

type SpanOp<'a> = (Span<'a>, Op);

type SpanOp<'a> = (Span<'a>, Op);

pub type SpanId<'a> = Span<'a>;

#[derive(Debug, Clone, PartialEq)]

#[derive(Debug, Clone, PartialEq)]

pub enum Expr<'a> {

pub enum Expr<'a> {

    Num(i32),

    Num(i32),

    Bool(bool),

    Par(Box<SpanExpr<'a>>),

    Par(Box<SpanExpr<'a>>),

    // Identifier

    Id(String),

    // Function application

    Call(String, Vec<SpanExpr<'a>>),

    BinOp(Op, Box<SpanExpr<'a>>, Box<SpanExpr<'a>>),

    BinOp(Op, Box<SpanExpr<'a>>, Box<SpanExpr<'a>>),

    UnaryOp(Op, Box<SpanExpr<'a>>),

    UnaryOp(Op, Box<SpanExpr<'a>>),

}

}

pub type SpanExpr<'a> = (Span<'a>, Expr<'a>);

pub type SpanExpr<'a> = (Span<'a>, Expr<'a>);

#[derive(Debug, PartialEq, Clone)]

pub enum Cmd<'a> {

    // let <mut> id : <& <mut>>Type = expr

    Let(Mutability, SpanId<'a>, Type, SpanExpr<'a>),

    // id = expr

    Assign(SpanExpr<'a>, SpanExpr<'a>),

    // if predicate do-this, and optionally do-that)

    If(SpanExpr<'a>, Block<'a>, Option<Block<'a>>),

    // while predicate do-this

    While(SpanExpr<'a>, Block<'a>),

    Return(SpanExpr<'a>),

}

pub type SpanCmd<'a> = (Span<'a>, Cmd<'a>);

#[derive(Debug, PartialEq, Clone)]

pub enum Mutability {

    Imm,

    Mut,

}

pub type SpanMut<'a> = (Span<'a>, Mutability);

pub type SpanBlock<'a> = (Span<'a>, Vec<SpanCmd<'a>>);

pub type Block<'a> = Vec<Cmd<'a>>;

#[derive(Debug, PartialEq, Clone)]

pub enum Type {

    I32,

    Bool,

    Unit,

    Mut(Box<Type>),

    Ref(Box<Type>),

    // no structs

}

// pub type SpanType<'a> = (Span<'a>, Type<'a>);

#[derive(Debug, PartialEq, Clone)]

pub struct Func<'a> {

    pub sig: (SpanId<'a>, Vec<(SpanId<'a>, Type)>, Type),

    pub body: Block<'a>,

}

#[derive(Debug, PartialEq, Clone)]

pub enum Item<'a> {

    Func(Func<'a>),

}

pub type Prog<'a> = Vec<Item<'a>>;

// Interpreter

use crate::ast::{Expr, Op, SpanExpr};

pub fn eval_expr(e: &SpanExpr) -> i32 {

    match e.clone().1 {

        Expr::Num(i) => i,

        Expr::BinOp(op, l, r) => {

            let lv = eval_expr(&l);

            let rv = eval_expr(&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 = eval_expr(&e);

            match op {

                Op::Add => e,

                Op::Sub => -e,

                _ => unimplemented!(),

            }

        }

        _ => unimplemented!(),

    }

}

// use crate::ast::{Binop, Cmd, Constant, Expr, Item, Prog, TypeDecl};

// use crate::check::{check_prog, Fenv, Tenv};

// use crate::parse::parse_prog;

//use std::collections::HashMap;

// pub type Addr = u32;

// #[derive(Debug, PartialEq, Clone)]

// pub enum Data {

//     Value(Constant),

//     Pointer(Addr),

// }

// pub type Venv = HashMap<String, Addr>;

// pub type Menv = HashMap<Addr, Data>;

// #[derive(Debug, PartialEq, Clone)]

// pub struct Mem {

//     pub Addr: u32,

//     pub Menv: Menv,

// }

// impl Mem {

//     fn new() -> Mem {

//         Mem {

//             Addr: 0,

//             Menv: Menv::new(),