bnf and parsing function body

loxGrammar.bnf

@@ -32,6 +32,13 @@
 
 <declaration> ::= <variableDeclaration>
                 | <statement>
+                | <functionDeclaration>
+
+<functionDeclaration> ::= "fun" <function>
+
+<function> ::= <identifier> "(" <parameters> ")" <block>
+
+<parameters> ::= <identifier> ( "," <identifier> )*
 
 <variableDeclaration> ::= "var " <identifier> ("=" <expression>) ";"
 

src/interpreter.rs

@@ -90,6 +90,13 @@ impl Interpreter {
                         self.interpret_statements(vec![*body.clone()])?; // fix here??
                     }
                 }
+                Statement::Function {
+                    name,
+                    parameters,
+                    body,
+                } => {
+                    todo!()
+                }
             };
         }
 

src/parser.rs

@@ -56,9 +56,47 @@ impl Parser {
             };
         }
 
+        if self.match_tokens(vec![Fun]) {
+            self.function("function")?;
+        }
+
         self.statement()
     }
 
+    fn function(&mut self, kind: &str) -> Result<Statement, String> {
+        let function_name = self.consume(Identifier, &format!("Expect {} name", kind))?;
+
+        self.consume(LeftParen, &format!("Expect '(' after {} name", kind))?;
+
+        let mut parameters = vec![];
+
+        if !self.check(RightParen) {
+            loop {
+                if parameters.len() >= 255 {
+                    return Err(String::from("Can't have more than 255 parameters."));
+                }
+
+                parameters.push(self.consume(Identifier, "Expect parameter name")?);
+
+                if !self.match_tokens(vec![Comma]) {
+                    break;
+                }
+            }
+        }
+
+        self.consume(RightParen, "Expect ')' after parameters")?;
+
+        self.consume(LeftBrace, &format!("Expect '{{' before {} body", kind))?;
+
+        let body = self.blocks()?;
+
+        Ok(Statement::Function {
+            name: function_name,
+            parameters: parameters,
+            body: body,
+        })
+    }
+
     fn variable_declaration(&mut self) -> Result<Statement, String> {
         let token_name = self.consume(Identifier, "Expect variable name")?;
 

src/statement.rs

@@ -30,4 +30,10 @@ pub enum Statement {
         condition: expression::Expression,
         body: Box<Statement>,
     },
+
+    Function {
+        name: Token,
+        parameters: Vec<Token>,
+        body: Vec<Statement>,
+    },
 }