feat: add support for si/sinon

examples/conditions.fr

@@ -0,0 +1,11 @@
+programme Conditions
+début
+  avec ma_condition : booléen
+
+  ma_condition <- vrai
+
+  si
+  ma_condition
+  alors afficher "c'est vrai !\n"
+  fin si
+fin Conditions

src/ast/index.ts

@@ -24,7 +24,7 @@ import {
   NotToken
 } from "../lexer/tokens";
 
-import { IntegerNumber, BinaryOperation, UnaryOperation, type AST, Compound, NoOp, Variable, Assign, Program, Type, VariableDeclaration, RealNumber, StringConstant, GlobalScope, Procedure, ArgumentVariable, ProcedureCall, CharConstant, BooleanConstant } from "./nodes";
+import { IntegerNumber, BinaryOperation, UnaryOperation, type AST, Compound, NoOp, Variable, Assign, Program, Type, VariableDeclaration, RealNumber, StringConstant, GlobalScope, Procedure, ArgumentVariable, ProcedureCall, CharConstant, BooleanConstant, If } from "./nodes";
 
 export class Parser {
   /** Current token instance. */
@@ -318,30 +318,31 @@ export class Parser {
     return root;
   }
 
-  /** statement_list : statement | statement \n statement_list */
-  private statement_list (): Array<AST> {
-    const node = this.statement();
-    const results = [node];
+  /**
+   * statement_list : (statement)*
+   *
+   * Handles statements until it reaches an END token or an
+   * ELSE token (if it's inside an IF statement -> `insideIf === true`).
+   */
+  private statement_list (insideIf = false): Array<AST> {
+    const results = [];
 
     // After the first statement, we expect the token to be a line break.
     // So we can loop on every statement until we reach the end of the program.
+    const isStatementsEnd = () => this.current_token?.type === TokenType.END || (
+      insideIf && this.current_token?.type === TokenType.ELSE
+    );
 
+    while (!isStatementsEnd()) {
+      // Eat every newline token between statements.
+      this.skip_newlines();
 
-    while (this.current_token?.type === TokenType.LINE_BREAK) {
-      // Eat the line break and move to next token.
-      this.eat(TokenType.LINE_BREAK);
-
-      // @ts-expect-error : We moved to next token.
-      // Check if the next token is the end of the program.
-      if (this.current_token?.type === TokenType.END) break;
+      // Check if the next token is the end of the statement list.
+      if (isStatementsEnd()) break;
 
       results.push(this.statement());
     }
 
-    if (this.current_token?.type !== TokenType.END) {
-      throw new Error(`Token attendu: END\nToken actuel: ${this.current_token?.type}`);
-    }
-
     return results;
   }
 
@@ -370,6 +371,10 @@ export class Parser {
       }
     }
 
+    else if (this.current_token?.type === TokenType.IF) {
+      return this.if_statement();
+    }
+
     return this.empty();
   }
 
@@ -427,6 +432,37 @@ export class Parser {
     return node;
   }
 
+  /**
+   * if_statement : SI expr ALORS statement_list (SINON statement_list)? FIN SI
+   */
+  private if_statement (): If {
+    this.eat(TokenType.IF);
+    const condition = this.expr();
+
+    // Possible to add a newline before the `then` token.
+    this.skip_newlines();
+    this.eat(TokenType.THEN);
+
+    const main_statements = this.statement_list(true);
+    let else_statements: AST[] | undefined;
+
+    if (this.current_token?.type === TokenType.ELSE) {
+      this.eat(TokenType.ELSE);
+      else_statements = this.statement_list();
+    }
+
+    const node = new If(
+      condition,
+      main_statements,
+      else_statements
+    );
+
+    this.eat(TokenType.END);
+    this.eat(TokenType.IF);
+
+    return node;
+  }
+
   /**
    * Handles the variable node.
    * variable: ID
@@ -451,6 +487,7 @@ export class Parser {
    * Such as unary operations, numbers, parenthesis, etc.
    */
   private factor (): BinaryOperation | IntegerNumber | RealNumber | UnaryOperation | Variable | CharConstant | StringConstant | BooleanConstant {
+    this.skip_newlines();
     const token = this.current_token!;
 
     switch (token.type) {
@@ -479,6 +516,10 @@ export class Parser {
       case TokenType.LPAREN: {
         this.eat(TokenType.LPAREN);
         const node = this.expr();
+
+        // Possible to add a newline before the closing parenthesis.
+        this.skip_newlines();
+
         this.eat(TokenType.RPAREN);
         return node;
       }

src/ast/nodes.ts

@@ -87,6 +87,16 @@ export class Program {
   ) {}
 }
 
+export class If {
+  public type = "If";
+
+  constructor (
+    public condition: BinaryOperation | IntegerNumber | UnaryOperation | Variable | CharConstant | StringConstant | BooleanConstant,
+    public main_statements: AST[] = [],
+    public else_statements: AST[] = []
+  ) {}
+}
+
 export class Procedure {
   public type = "Procedure";
   public args: VariableDeclaration[] = [];

src/interpreter/index.ts

@@ -1,4 +1,4 @@
-import { AST, Assign, BinaryOperation, BooleanConstant, CharConstant, Compound, GlobalScope, IntegerNumber, ProcedureCall, Program, RealNumber, StringConstant, UnaryOperation, Variable } from "../ast/nodes";
+import { AST, Assign, BinaryOperation, BooleanConstant, CharConstant, Compound, GlobalScope, If, IntegerNumber, ProcedureCall, Program, RealNumber, StringConstant, UnaryOperation, Variable } from "../ast/nodes";
 import { TypeBooleanOperationError, TypeOperationError } from "../errors/math";
 import { TokenType } from "../lexer/tokens";
 import { builtinProcedures } from "./builtins";
@@ -24,6 +24,8 @@ class Interpreter {
         return this.visitUnaryOperation(node as UnaryOperation);
       case "Compound":
         return this.visitCompound(node as Compound);
+      case "If":
+        return this.visitIf(node as If);
       case "Assign":
         return this.visitAssign(node as Assign);
       case "Variable":
@@ -285,6 +287,21 @@ class Interpreter {
     }
   }
 
+  private async visitIf (node: If): Promise<void> {
+    const condition = await this.visit(node.condition);
+
+    if (condition) {
+      for (const statement of node.main_statements) {
+        await this.visit(statement);
+      }
+    }
+    else if (!condition && node.else_statements.length > 0) {
+      for (const statement of node.else_statements) {
+        await this.visit(statement);
+      }
+    }
+  }
+
   private async visitAssign (node: Assign): Promise<void> {
     const variableName = node.left.value;
     const newVariableValue = await this.visit(node.right);

src/lexer/index.ts

@@ -37,7 +37,10 @@ import {
   GreaterThanToken,
   EqualToken,
   NotToken,
-  NotEqualToken
+  NotEqualToken,
+  IfToken,
+  ThenToken,
+  ElseToken
 } from "./tokens";
 
 const RESERVED_KEYWORDS = {
@@ -47,6 +50,9 @@ const RESERVED_KEYWORDS = {
   "début": new BeginToken(),
   "avec": new VariableDeclarationBlockToken(),
   "fin": new EndToken(),
+  "si": new IfToken(),
+  "sinon": new ElseToken(),
+  "alors": new ThenToken(),
 
   // Operator.
   "mod": new ModToken(),

src/lexer/tokens.ts

@@ -11,6 +11,10 @@ export enum TokenType {
   MOD = "MOD",
   NOT = "NOT",
 
+  IF = "IF",
+  ELSE = "ELSE",
+  THEN = "THEN",
+
   EQUAL = "EQUAL",
   NOT_EQUAL = "NOT_EQUAL",
   LESS_THAN = "LOWER_THAN",
@@ -52,6 +56,24 @@ class BaseToken<T> {
   ) {}
 }
 
+export class IfToken extends BaseToken<string> {
+  constructor () {
+    super(TokenType.IF, "si");
+  }
+}
+
+export class ElseToken extends BaseToken<string> {
+  constructor () {
+    super(TokenType.ELSE, "sinon");
+  }
+}
+
+export class ThenToken extends BaseToken<string> {
+  constructor () {
+    super(TokenType.THEN, "alors");
+  }
+}
+
 export class IntegerToken extends BaseToken<string> {
   constructor () {
     super(TokenType.INTEGER, "entier");

src/symbols/visitor.ts

@@ -1,4 +1,4 @@
-import { AST, Assign, BinaryOperation, Compound, GlobalScope, Procedure, ProcedureCall, Program, StringConstant, UnaryOperation, Variable, VariableDeclaration } from "../ast/nodes";
+import { AST, Assign, BinaryOperation, Compound, GlobalScope, If, Procedure, ProcedureCall, Program, StringConstant, UnaryOperation, Variable, VariableDeclaration } from "../ast/nodes";
 import { TypeOperationError, TypeOperationVariableError } from "../errors/math";
 import { UndeclaredVariableTypeError } from "../errors/variables";
 import { TokenType } from "../lexer/tokens";
@@ -31,6 +31,8 @@ class SemanticAnalyzer {
         return this.visitUnaryOperation(<UnaryOperation>node);
       case "Compound":
         return this.visitCompound(<Compound>node);
+      case "If":
+        return this.visitIf(<If>node);
       case "VariableDeclaration":
         return this.visitVariableDeclaration(<VariableDeclaration>node);
       case "Assign":
@@ -163,13 +165,24 @@ class SemanticAnalyzer {
 
         break;
       }
+
       /**
-       * When it's a "+" operation, we can have
-       * operations with every numbers but also strings.
+       * Conditional operators can be used on anything.
+       *
+       * A "+" operation can have
+       * operations with anything except booleans.
        */
+      case TokenType.EQUAL:
+      case TokenType.GREATER_THAN:
+      case TokenType.GREATER_THAN_OR_EQUAL:
+      case TokenType.LESS_THAN:
+      case TokenType.LESS_THAN_OR_EQUAL:
       case TokenType.PLUS:
         this.visit(node.left);
         this.visit(node.right);
+        break;
+      default:
+        throw new Error("Erreur<symbols.visitBinaryOperation> de syntaxe.\ndebug: unknown binary operation.");
     }
   }
 
@@ -189,6 +202,18 @@ class SemanticAnalyzer {
     }
   }
 
+  private visitIf (node: If): void {
+    this.visit(node.condition);
+
+    for (const statement of node.main_statements) {
+      this.visit(statement);
+    }
+
+    for (const statement of node.else_statements) {
+      this.visit(statement);
+    }
+  }
+
   private visitVariableDeclaration (node: VariableDeclaration): void {
     const type_name = node.type_node.value;
     const type_symbol: BuiltinTypeSymbol | undefined = this.current_scope!.lookup(type_name);