Structures pour représenter une expression et affichage d'un AST.

src/expr.rs

@@ -1,25 +1,25 @@
 use crate::token::Token;
 
 pub struct Binary {
-    left: Box<Expr>,
+    pub left: Box<Expr>,
-    operator: Token,
+    pub operator: Token,
-    right: Box<Expr>,
+    pub right: Box<Expr>,
 }
 
 pub struct Grouping {
-    expression: Box<Expr>,
+    pub expression: Box<Expr>,
 }
 
 pub enum Literal {
-    LiteralNumber(i8),
+    LiteralNumber(f64),
     LiteralString(String),
     LiteralBool(bool),
     LiteralNil,
 }
 
 pub struct Unary {
-    operator: Token,
+    pub operator: Token,
-    right: Box<Expr>,
+    pub right: Box<Expr>,
 }
 
 pub enum Expr {
@@ -29,11 +29,11 @@ pub enum Expr {
     UnaryExpr(Unary),
 }
 
-pub trait Visitor {
+pub trait Visitable {
     fn visit(&self);
 }
 
-impl Visitor for Binary {
+impl Visitable for Binary {
     fn visit(&self) {
         print!("( {}",&self.operator.literal);
         &self.left.visit();
@@ -42,7 +42,7 @@ impl Visitor for Binary {
     }
 }
 
-impl Visitor for Grouping {
+impl Visitable for Grouping {
     fn visit(&self) {
         print!("( group ");
         &self.expression.visit();
@@ -50,7 +50,7 @@ impl Visitor for Grouping {
     }
 }
 
-impl Visitor for Literal {
+impl Visitable for Literal {
     fn visit(&self) {
         match &self {
             Literal::LiteralNumber(i) => print!("{}", i),
@@ -61,7 +61,7 @@ impl Visitor for Literal {
     }
 }
 
-impl Visitor for Unary {
+impl Visitable for Unary {
     fn visit(&self) {
         print!("( {}",&self.operator.literal);
         &self.right.visit();
@@ -69,8 +69,13 @@ impl Visitor for Unary {
     }
 }
 
-impl Visitor for Expr {
+impl Visitable for Expr {
     fn visit(&self) {
-        &self.visit();
+        match &self {
+            Expr::BinaryExpr(b) => { b.visit(); }
+            Expr::GroupingExpr(g) => { g.visit(); }
+            Expr::LiteralExpr(l) => { l.visit(); }
+            Expr::UnaryExpr(u) => { u.visit(); }
+        }
     }
 }

src/main.rs

@@ -1,6 +1,7 @@
 use std::env;
 use std::process;
-use crate::expr::Expr;
+use crate::expr::{Binary, Expr, Grouping, Literal, Unary, Visitable};
+use crate::expr::Expr::LiteralExpr;
 
 mod rlox_interpreter;
 mod scanner;
@@ -9,6 +10,8 @@ mod token_type;
 mod expr;
 
 use crate::rlox_interpreter::RLoxInterpreter;
+use crate::token::Token;
+use crate::token_type::TokenType;
 
 // Exit codes from #include <sysexits.h>
 const EX_OK: i32 = 0;
@@ -18,6 +21,8 @@ const EX_USAGE : i32 = 66;
 fn main() {
     let args: Vec<String> = env::args().collect();
 
+    essai_visitor();
+
     let exit_code = match args.len() {
         1 => { RLoxInterpreter::new().run_prompt() } ,
         2 => { RLoxInterpreter::new().run_file(&args[1]) },
@@ -30,6 +35,30 @@ fn main() {
     process::exit(exit_code);
 }
 
+fn essai_visitor() {
+    let expression = Expr::BinaryExpr(Binary {
+        left: Box::new(Expr::UnaryExpr( Unary {
+            operator: Token {
+                token_type: TokenType::Minus,
+                lexeme: String::from("-"),
+                line: 0,
+                literal: String::from("-")
+            },
+            right: Box::new(Expr::LiteralExpr(Literal::LiteralNumber(123.0)))
+        })),
+        operator: Token {
+            token_type: TokenType::Star,
+            lexeme: String::from("*"),
+            line: 0,
+            literal: String::from("*")
+        },
+        right: Box::new(Expr::GroupingExpr ( Grouping {
+                expression: Box::new(LiteralExpr(Literal::LiteralNumber(123.0)))
+        }))
+    });
+
+    expression.visit();
+}
 
 
 // Implémentations de référence :