Added rules for borrow checking

HOME_EXAM.md

@@ -117,6 +117,7 @@ Decl
     :"let" Id ":" Type? "=" Expr
     |"let mut" Id ":" Type? "=" Expr
     |Id "=" Expr
+    |"*" Id "=" Expr
     ;
 ```
 
@@ -186,6 +187,14 @@ PrefixOp
 
 ```ebnf
 Type
+    :"&" Types
+    |"&" "mut" Types
+    |Types
+    ;
+```
+
+```ebnf
+Types
     :"i32"
     |"bool"
     |"()"
@@ -197,6 +206,9 @@ NumOrId
     :Num
     |Id
     |Bool
+    |"&" Id
+    |"&" "mut" Id
+    |"*" Id
     ;
 ```
 
@@ -248,6 +260,19 @@ The following program will be accepted by the parser.
     }
 ```
 
+```rust
+fn b(x: &mut i32, y: &mut i32) -> () {
+        *x = *x + 1;
+        *y = *y + 1;
+    };
+    fn main() -> () {
+        let mut x: i32 = 5;
+        let mut y: i32 = 5;
+        b(&mut x, &mut y);
+    }
+```
+Example of references accepted by my compiler
+
 #### Illeagal examples
 Three examples that will not go through the parser and be rejected by the compiler:
 ```rust
@@ -290,6 +315,7 @@ The following bullet points are covered by the parser.
 - While
 - Expressions (parenthesized expressions, prefix, several operands, precedence)
 - Types: bool, i32 and unit
+- References, mutable references, dereferenced assignments
 
 All statements have explicit types.
 
@@ -350,6 +376,20 @@ Can also be combined in a derivation tree.
     3 <= 5;
 ```
 
+##### Unary operations
+```math
+\frac{<e0,σ> → n0}{<-e0,σ> → n}, \text{ where } n = -n0
+```
+SOS for unary - for one expression.
+
+Similar SOS goes for the following operands:
+- "!", not
+
+```rust
+    -(5+1);
+    !false;
+```
+
 ##### Assignment
 ```math
 \frac{<e,σ> → n}{<x:=e,σ> → σ[x:=n]}
@@ -401,6 +441,14 @@ Let statements works in a similiar way.
     }
 ```
 
+##### Functioncall
+```math
+\frac{}{};
+```
+
+```rust
+```
+
 #### Showcase step by step
 When looking at the showcase and the SOS for the langugage can it be seen that the program will be executed in sequence. First will the value true be assigned to the variable start followed by a functioncall to test2(). Before executing test2() need the argument expression be evaluated and get the value true as seen in the first SOS and assign it to the variable x. In the scope for test2() will the variables a and b also be assigned followed by a functionfall to test1(). In test1() is a if then else introduced and following the SOS above does this return in true and the next if is evalueted which also is true. From here will a return statement be evalueted and the value 7 will be returned back to test2() and assign to variable c. Continuing in the method test2() will a while loop be started and because the expression is true will the block be evalueted as seen in the SOS for while. This will be repeted two more times before the expression becomes false and the state does not change. Finally is the value for variable b returned back to the main method. 
 
@@ -413,6 +461,7 @@ The following bullet points are covered by the interpreter.
 - If and else
 - While
 - Functioncalls (With return value)
+- References, mutable references, dereferenced assignments
 
 For the interpreter to accept a program is a main() method needed. 
 
@@ -471,6 +520,20 @@ Similar SOS goes for the following operand:
     true && 5; //Invalid type i32 for operand &&
 ```
 
+##### Unary operations
+```math
+\frac{<e0,σ> → i32}{<-e0,σ> → i32}
+```
+SOS for unary - for one expression.
+
+Similar SOS goes for the following operands:
+- "!", not (bool instead of i32)
+
+```rust
+    -(5+1);
+    !false;
+```
+
 ##### Assignment
 ```math
 \frac{<x,σ> → bool <e,σ> → bool}{<x:=e,σ> -> ()}
@@ -521,6 +584,14 @@ For the if statement to go through the type checker need the expression, e, be a
 ```
 The example above is valid for the type checker due to it only checking that the expression is a boolean. The interpreter will not execute the block statement due to the expression being false.  
 
+##### Functioncall
+```math
+\frac{}{};
+```
+
+```rust
+```
+
 #### Coverage
 The type checker rejects programs where:
 
@@ -530,6 +601,7 @@ The type checker rejects programs where:
 - If and while statements does not have a boolean as an expression
 - Function does not return the specified type
 - Variables not found in scope
+- References, mutable references, dereferenced assignments
 
 Information is being spawn about the error when occuring.