ASTを複数文に対応

Author: senrust

.gitignore

@@ -1,3 +1,3 @@
 /target
 *.s
-testset.txt
+/test

Makefile.toml

@@ -10,4 +10,9 @@ args = ["-r", "a.out", "tmp.s"]
 dependencies = [
     "test",
     "clean",
+]
+
+[tasks.arm]
+dependencies = [
+    "test",
 ]

src/ast.rs

@@ -1,9 +1,15 @@
 use super::tokenizer::{TokenList, OperationKind, ParenthesesKind};
 use super::error::error_exit;
 
+pub enum PrimaryNodeKind {
+    Number(i32),
+    Variable(char, i32),    // (variablename, offset from bsp)
+}
+
 pub enum ASTNodeKind {
     Operation(OperationKind),
-    Number(i32),
+    Primary(PrimaryNodeKind),
+    Assign,
 }
 
 pub struct ASTNode {
@@ -13,9 +19,9 @@ pub struct ASTNode {
 }
 
 impl ASTNode {
-    fn new_num_node(num: i32) -> ASTNode {
+    fn new_primary_node(primary_node: PrimaryNodeKind) -> ASTNode {
         ASTNode {
-            node_kind: ASTNodeKind::Number(num),
+            node_kind: ASTNodeKind::Primary(primary_node),
             left: None,
             right: None,
         }
@@ -29,23 +35,37 @@ impl ASTNode {
         }
     }
 
+    fn new_assign_node() -> ASTNode {
+        ASTNode {
+            node_kind: ASTNodeKind::Assign,
+            left: None,
+            right: None,
+        }
+    }
+
     // ASTNodeを更新
     fn add_neighbor_node(&mut self, left: Link, right: Link) {
         self.left = left;
         self.right = right;
     }
 }
 
-// AST 生成規則
-// expr       = equality
-// equality   = relational ("==" relational | "!=" relational)*
-// relational = add ("<" add | "<=" add | ">" add | ">=" add)*
-// add        = mul ("+" mul | "-" mul)*
-// mul        = unary ("*" unary | "/" unary)*
-// unary      = ("+" | "-")? primary
-// primary    = num | "(" expr ")"
+/*
+AST 生成規則
+program    = stmt*
+stmt       = expr ";"
+expr       = assign
+assign     = equality ("=" assign)?
+equality   = relational ("==" relational | "!=" relational)*
+relational = add ("<" add | "<=" add | ">" add | ">=" add)*
+add        = mul ("+" mul | "-" mul)*
+mul        = unary ("*" unary | "/" unary)*
+unary      = ("+" | "-")? primary
+primary    = num | ident | "(" expr ")"
+*/
 
 type Link = Option<Box<ASTNode>>;
+// ;で区切られた領域のASTを作成する
 pub struct AST {
     pub root: Link,
 }
@@ -56,18 +76,27 @@ impl AST {
         let ast_tree = AST {
             root: AST::expr(token_list),
         };
-        // トークン連想配列が空でない場合、exprでNode化できていないトークンがあるのでエラーにする
-        if !token_list.is_empty() {
-            let rem_token = token_list.head.take().unwrap();
-            error_exit("this token is invalid", rem_token.token_pos, &token_list.raw_text);
-        }
         ast_tree
     }
 
+    // expr  = assign
     fn expr(token_list: &mut TokenList) ->  Link {
-        AST::equality(token_list)
+        AST::assign(token_list)
     }
 
+    // assign = equality ("=" assign)?
+    fn assign(token_list: &mut TokenList) ->  Link {
+        let mut assign_node = AST::equality(token_list);
+        
+        if token_list.consume_assign() {
+            let mut new_node = ASTNode::new_assign_node();
+            new_node.add_neighbor_node(assign_node.take(), AST::assign(token_list));
+            assign_node = Some(Box::new(new_node));
+        }
+        assign_node
+    }
+
+    // equality   = relational ("==" relational | "!=" relational)*
     fn equality(token_list: &mut TokenList) ->  Link {
         let mut equality_node = AST::relational(token_list);
 
@@ -87,6 +116,7 @@ impl AST {
         equality_node
     }
 
+    // relational = add ("<" add | "<=" add | ">" add | ">=" add)*
     fn relational(token_list: &mut TokenList) ->  Link {
         let mut relational_node = AST::add(token_list);
 
@@ -115,6 +145,7 @@ impl AST {
         relational_node
     }
 
+    // add = mul ("+" mul | "-" mul)*
     fn add(token_list: &mut TokenList) ->  Link {
         let mut expr_node = AST::mul(token_list);
 
@@ -134,6 +165,7 @@ impl AST {
         expr_node
     }
 
+    // mul  = unary ("*" unary | "/" unary)*
     fn mul(token_list: &mut TokenList) -> Link {
         let mut mul_node = AST::urany(token_list);
 
@@ -153,19 +185,21 @@ impl AST {
         mul_node
     }
 
+    // unary = ("+" | "-")? primary
     fn urany(token_list: &mut TokenList) -> Link {
         if token_list.consume_operation(OperationKind::Add) {
             return AST::primary(token_list); 
         }
         if token_list.consume_operation(OperationKind::Sub) {
             let mut new_node = ASTNode::new_operand_node(OperationKind::Sub);
-            let zoro_node = ASTNode::new_num_node(0);
+            let zoro_node = ASTNode::new_primary_node(PrimaryNodeKind::Number(0));
             new_node.add_neighbor_node(Some(Box::new(zoro_node)), AST::primary(token_list));
             return Some(Box::new(new_node));
         } 
         return AST::primary(token_list);
     }
 
+    // primary    = num | ident | "(" expr ")"
     fn primary(token_list: &mut TokenList) ->  Link {
         if token_list.comsume_parentheses(ParenthesesKind::LeftParentheses) {
             let node = AST::expr(token_list);
@@ -181,7 +215,43 @@ impl AST {
                 }
             }
         }
-        return Some(Box::new(ASTNode::new_num_node(token_list.expect_number())));
+        return Some(Box::new(ASTNode::new_primary_node(token_list.expect_primary())));
+    }
+}
+
+/*
+AST 生成規則
+program    = stmt*
+stmt       = expr ";" 
+expr       = assign
+assign     = equality ("=" assign)?
+equality   = relational ("==" relational | "!=" relational)*
+relational = add ("<" add | "<=" add | ">" add | ">=" add)*
+add        = mul ("+" mul | "-" mul)*
+mul        = unary ("*" unary | "/" unary)*
+unary      = ("+" | "-")? primary
+primary    = num | ident | "(" expr ")"
+*/
+// ASTはstmt単位で作成し,
+// ASTのリストをASTVecとして保存する
+pub struct ASTVec {
+    pub vec: Vec<AST>, 
+} 
+
+impl ASTVec {
+    fn new() -> ASTVec {
+        ASTVec {
+            vec: vec!(),
+        }
     }
 
+    pub fn make_ast_vec(token_list: &mut TokenList) -> ASTVec{
+        let mut ast_vec = ASTVec::new();
+        while !token_list.is_empty() {
+            let ast : AST = AST::new(token_list);
+            token_list.consume_statement_end();
+            ast_vec.vec.push(ast);
+        }
+        ast_vec
+    }
 }

src/compiler.rs

@@ -1,8 +1,8 @@
-use crate::ast::{AST, ASTNode, ASTNodeKind};
+use crate::ast::{AST, ASTNode, ASTNodeKind, PrimaryNodeKind};
 use super::tokenizer::OperationKind;
 
 fn compile_node(mut node: ASTNode, instruction_vec: &mut Vec<String>) {
-    if let ASTNodeKind::Number(num) = node.node_kind {
+    if let ASTNodeKind::Primary(PrimaryNodeKind::Number(num)) = node.node_kind {
         let instruction = format!("    push {}", num);
         instruction_vec.push(instruction);
         return;

src/tests.rs

@@ -2,9 +2,13 @@
 mod tests {
     use std::fs::File;
     use std::io::{BufRead, BufReader};
+    #[cfg(target_arch = "x86")]
     use std::process::Command;
-    use crate::output_asembly;
 
+    use crate::tokenizer;
+    use crate::ast;
+
+    #[cfg(target_arch = "x86")]
     fn make_binary_from_asm() {
         Command::new("cc")
             .arg("-o")
@@ -14,6 +18,7 @@ mod tests {
             .expect("failed to asemble binary");
     }
 
+    #[cfg(target_arch = "x86")]
     fn compare_output() -> i32{
         let status = Command::new("sh")
             .arg("-c")
@@ -26,8 +31,10 @@ mod tests {
     }
 
     #[test]
+    #[cfg(target_arch = "x86")]
     fn compiler_test() {
-        let f = File::open("testset.txt").unwrap();
+        use crate::output_asembly;
+        let f = File::open("./test/binary_test.txt").unwrap();
         for line_result in BufReader::new(f).lines() {
             let test_set = line_result.unwrap();
             let test_vec: Vec<&str> = test_set.split(",").collect();
@@ -45,4 +52,16 @@ mod tests {
             }
         }
     }
+
+    #[test]
+    fn ast_test() {
+        let f = File::open("./test/ast_test.txt").unwrap();
+        for line_result in BufReader::new(f).lines() {
+            let ast_text = line_result.unwrap();
+            println!("try making ast of {}", ast_text);
+            let mut token_list = tokenizer::text_tokenizer(&ast_text);
+            ast::ASTVec::make_ast_vec(&mut token_list);
+            println!("suceeded!");
+        }
+    }
 }