@devalade/algolang 1.0.0 → 2.0.0

package/dist/cli.js

@@ -1,5 +1,4 @@
 #!/usr/bin/env node
-#!/usr/bin/env bun
 // @bun
 import { createRequire } from "node:module";
 var __create = Object.create;
@@ -2633,6 +2632,268 @@ var chalk = createChalk();
 var chalkStderr = createChalk({ level: stderrColor ? stderrColor.level : 0 });
 var source_default = chalk;
 
+// src/keywords.ts
+var KEYWORDS = {
+  PROGRAMME: {
+    tokenType: "PROGRAMME" /* PROGRAM */,
+    kind: "control",
+    detail: "Mot-clé PROGRAMME",
+    documentation: "**PROGRAMME** : Début d'un programme AlgoLang."
+  },
+  DEBUT: {
+    tokenType: "DEBUT" /* BEGIN */,
+    kind: "control",
+    detail: "Mot-clé DEBUT",
+    documentation: "**DEBUT** : Début du bloc d'instructions principal."
+  },
+  FIN: {
+    tokenType: "FIN" /* END */,
+    kind: "control",
+    detail: "Mot-clé FIN",
+    documentation: "**FIN** : Fin du bloc d'instructions ou du programme."
+  },
+  VAR: {
+    tokenType: "VAR" /* VAR */,
+    kind: "declaration",
+    detail: "Mot-clé VAR",
+    documentation: "**VAR** : Section de déclaration des variables."
+  },
+  ENTIER: {
+    tokenType: "ENTIER" /* INTEGER */,
+    kind: "type",
+    detail: "Type ENTIER",
+    documentation: "**ENTIER** : Type de donnée pour les nombres entiers."
+  },
+  REEL: {
+    tokenType: "REEL" /* REAL */,
+    kind: "type",
+    detail: "Type REEL",
+    documentation: "**REEL** : Type de donnée pour les nombres à virgule."
+  },
+  BOOLEEN: {
+    tokenType: "BOOLEEN" /* BOOLEAN */,
+    kind: "type",
+    detail: "Type BOOLEEN",
+    documentation: "**BOOLEEN** : Type de donnée logique (VRAI/FAUX)."
+  },
+  CHAINE: {
+    tokenType: "CHAINE" /* STRING */,
+    kind: "type",
+    detail: "Type CHAINE",
+    documentation: "**CHAINE** : Type de donnée pour le texte."
+  },
+  SI: {
+    tokenType: "SI" /* IF */,
+    kind: "control",
+    detail: "Mot-clé SI",
+    documentation: "**SI** : Structure conditionnelle."
+  },
+  ALORS: {
+    tokenType: "ALORS" /* THEN */,
+    kind: "control",
+    detail: "Mot-clé ALORS",
+    documentation: "**ALORS** : Début du bloc exécuté si la condition est vraie."
+  },
+  SINON: {
+    tokenType: "SINON" /* ELSE */,
+    kind: "control",
+    detail: "Mot-clé SINON",
+    documentation: "**SINON** : Début du bloc exécuté si la condition est fausse."
+  },
+  FINSI: {
+    tokenType: "FINIF" /* ENDIF */,
+    kind: "control",
+    detail: "Mot-clé FINSI",
+    documentation: "**FINSI** : Fin d'une structure conditionnelle."
+  },
+  TANTQUE: {
+    tokenType: "TANTQUE" /* WHILE */,
+    kind: "control",
+    detail: "Mot-clé TANTQUE",
+    documentation: "**TANTQUE** : Boucle répétitive tant qu'une condition est vraie."
+  },
+  FAIRE: {
+    tokenType: "FAIRE" /* DO */,
+    kind: "control",
+    detail: "Mot-clé FAIRE",
+    documentation: "**FAIRE** : Début du corps d'une boucle."
+  },
+  FINTANTQUE: {
+    tokenType: "FINTANTQUE" /* ENDWHILE */,
+    kind: "control",
+    detail: "Mot-clé FINTANTQUE",
+    documentation: "**FINTANTQUE** : Fin d'une boucle TANTQUE."
+  },
+  POUR: {
+    tokenType: "POUR" /* FOR */,
+    kind: "control",
+    detail: "Mot-clé POUR",
+    documentation: "**POUR** : Boucle avec compteur."
+  },
+  ALLANT: {
+    tokenType: "ALLANT" /* ALLANT */,
+    kind: "control",
+    detail: "Mot-clé ALLANT",
+    documentation: "**ALLANT** : Utilisé dans une boucle POUR pour spécifier la plage."
+  },
+  DE: {
+    tokenType: "DE" /* DE */,
+    kind: "control",
+    detail: "Mot-clé DE",
+    documentation: "**DE** : Spécifie le début d'une plage dans une boucle POUR."
+  },
+  A: {
+    tokenType: "A" /* TO */,
+    kind: "control",
+    detail: "Mot-clé A",
+    documentation: "**A** : Spécifie la fin d'une plage dans une boucle POUR."
+  },
+  FINPOUR: {
+    tokenType: "FINPOUR" /* ENDFOR */,
+    kind: "control",
+    detail: "Mot-clé FINPOUR",
+    documentation: "**FINPOUR** : Fin d'une boucle POUR."
+  },
+  REPETER: {
+    tokenType: "REPETER" /* REPEAT */,
+    kind: "control",
+    detail: "Mot-clé REPETER",
+    documentation: "**REPETER** : Boucle exécutée au moins une fois."
+  },
+  "JUSQU'A": {
+    tokenType: "JUSQU'A" /* UNTIL */,
+    kind: "control",
+    detail: "Mot-clé JUSQU'A",
+    documentation: "**JUSQU'A** : Condition de fin d'une boucle REPETER."
+  },
+  LIRE: {
+    tokenType: "LIRE" /* READ */,
+    kind: "io",
+    detail: "Fonction LIRE",
+    documentation: "**LIRE(variable)** : Lit une valeur depuis l'entrée standard."
+  },
+  ECRIRE: {
+    tokenType: "ECRIRE" /* WRITE */,
+    kind: "io",
+    detail: "Fonction ECRIRE",
+    documentation: "**ECRIRE(...)** : Affiche des valeurs dans la console."
+  },
+  VRAI: {
+    tokenType: "VRAI" /* TRUE */,
+    kind: "literal",
+    detail: "Constante VRAI",
+    documentation: "**VRAI** : Valeur booléenne vraie."
+  },
+  FAUX: {
+    tokenType: "FAUX" /* FALSE */,
+    kind: "literal",
+    detail: "Constante FAUX",
+    documentation: "**FAUX** : Valeur booléenne fausse."
+  },
+  ET: {
+    tokenType: "ET" /* AND */,
+    kind: "operator",
+    detail: "Opérateur ET",
+    documentation: "**ET** : Opérateur logique ET (AND)."
+  },
+  OU: {
+    tokenType: "OU" /* OR */,
+    kind: "operator",
+    detail: "Opérateur OU",
+    documentation: "**OU** : Opérateur logique OU (OR)."
+  },
+  NON: {
+    tokenType: "NON" /* NOT */,
+    kind: "operator",
+    detail: "Opérateur NON",
+    documentation: "**NON** : Opérateur logique NON (NOT)."
+  },
+  TABLEAU: {
+    tokenType: "TABLEAU" /* ARRAY */,
+    kind: "declaration",
+    detail: "Type TABLEAU",
+    documentation: "**TABLEAU** : Déclare un tableau de n éléments.\nSyntaxe : `t: TABLEAU[10] DE ENTIER`"
+  },
+  FONCTION: {
+    tokenType: "FONCTION" /* FUNCTION */,
+    kind: "declaration",
+    detail: "Mot-clé FONCTION",
+    documentation: "**FONCTION** nom(params): TYPE : Déclare une fonction qui retourne une valeur.\nExemple : `FONCTION carre(n: ENTIER): ENTIER`"
+  },
+  PROCEDURE: {
+    tokenType: "PROCEDURE" /* PROCEDURE */,
+    kind: "declaration",
+    detail: "Mot-clé PROCEDURE",
+    documentation: "**PROCEDURE** nom(params) : Déclare une procédure (sans valeur de retour).\nExemple : `PROCEDURE afficher(s: CHAINE)`"
+  },
+  RETOURNER: {
+    tokenType: "RETOURNER" /* RETURN */,
+    kind: "declaration",
+    detail: "Mot-clé RETOURNER",
+    documentation: "**RETOURNER** expr : Retourne une valeur depuis une fonction."
+  },
+  abs: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction abs(x)",
+    documentation: "**abs(x)** : Retourne la valeur absolue de x."
+  },
+  max: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction max(a, b)",
+    documentation: "**max(a, b)** : Retourne le plus grand des deux nombres."
+  },
+  min: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction min(a, b)",
+    documentation: "**min(a, b)** : Retourne le plus petit des deux nombres."
+  },
+  mod: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction mod(a, b)",
+    documentation: "**mod(a, b)** : Retourne le reste de la division de a par b. Équivalent à `a % b`."
+  },
+  racine_carree: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction racine_carree(x)",
+    documentation: "**racine_carree(x)** : Retourne la racine carrée de x."
+  },
+  taille: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction taille(x)",
+    documentation: "**taille(x)** : Retourne la taille d'un tableau ou la longueur d'une chaîne."
+  },
+  sous_chaine: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction sous_chaine(s, i, n)",
+    documentation: "**sous_chaine(s, i, n)** : Retourne n caractères de la chaîne s à partir de l'indice i."
+  },
+  concat: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction concat(a, b)",
+    documentation: "**concat(a, b)** : Concatène deux chaînes de caractères."
+  },
+  entier_en_reel: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction entier_en_reel(x)",
+    documentation: "**entier_en_reel(x)** : Convertit un entier en réel."
+  },
+  reel_en_entier: {
+    tokenType: null,
+    kind: "builtin-function",
+    detail: "Fonction reel_en_entier(x)",
+    documentation: "**reel_en_entier(x)** : Convertit un réel en entier (troncature)."
+  }
+};
+
 // src/lexer/lexer.ts
 class Lexer {
   source;
@@ -2642,37 +2903,7 @@ class Lexer {
   keywords;
   constructor(source) {
     this.source = source;
-    this.keywords = new Map([
-      ["PROGRAMME", "PROGRAMME" /* PROGRAM */],
-      ["DEBUT", "DEBUT" /* BEGIN */],
-      ["FIN", "FIN" /* END */],
-      ["VAR", "VAR" /* VAR */],
-      ["ENTIER", "ENTIER" /* INTEGER */],
-      ["REEL", "REEL" /* REAL */],
-      ["BOOLEEN", "BOOLEEN" /* BOOLEAN */],
-      ["CHAINE", "CHAINE" /* STRING */],
-      ["SI", "SI" /* IF */],
-      ["ALORS", "ALORS" /* THEN */],
-      ["SINON", "SINON" /* ELSE */],
-      ["FINSI", "FINIF" /* ENDIF */],
-      ["TANTQUE", "TANTQUE" /* WHILE */],
-      ["FAIRE", "FAIRE" /* DO */],
-      ["POUR", "POUR" /* FOR */],
-      ["ALLANT", "ALLANT" /* ALLANT */],
-      ["DE", "DE" /* DE */],
-      ["A", "A" /* TO */],
-      ["REPETER", "REPETER" /* REPEAT */],
-      ["JUSQUA", "JUSQUA" /* UNTIL */],
-      ["LIRE", "LIRE" /* READ */],
-      ["ECRIRE", "ECRIRE" /* WRITE */],
-      ["VRAI", "VRAI" /* TRUE */],
-      ["FAUX", "FAUX" /* FALSE */],
-      ["ET", "ET" /* AND */],
-      ["OU", "OU" /* OR */],
-      ["NON", "NON" /* NOT */],
-      ["FINPOUR", "FINPOUR" /* ENDFOR */],
-      ["FINTANTQUE", "FINTANTQUE" /* ENDWHILE */]
-    ]);
+    this.keywords = new Map(Object.entries(KEYWORDS).filter(([, e]) => e.tokenType !== null).map(([label, e]) => [label, e.tokenType]));
   }
   tokenize() {
     const tokens = [];
@@ -2745,6 +2976,8 @@ class Lexer {
         return this.createToken("MULTIPLY" /* MULTIPLY */, this.advance());
       case "/":
         return this.createToken("DIVIDE" /* DIVIDE */, this.advance());
+      case "%":
+        return this.createToken("MODULO" /* MODULO */, this.advance());
       case "=":
         return this.createToken("EQUAL" /* EQUAL */, this.advance());
       case "<":
@@ -2763,6 +2996,10 @@ class Lexer {
         return this.createToken("LEFT_PAREN" /* LEFT_PAREN */, this.advance());
       case ")":
         return this.createToken("RIGHT_PAREN" /* RIGHT_PAREN */, this.advance());
+      case "[":
+        return this.createToken("LEFT_BRACKET" /* LEFT_BRACKET */, this.advance());
+      case "]":
+        return this.createToken("RIGHT_BRACKET" /* RIGHT_BRACKET */, this.advance());
       default:
         throw new Error(`Caractère non reconnu '${char}' à la ligne ${this.line}, colonne ${this.column}`);
     }
@@ -2955,87 +3192,108 @@ class Lexer {
   }
 }
 
+// src/semantic/semantic-analyzer.ts
+class SemanticAnalyzer {
+  symbolTable = {
+    symbols: new Map,
+    children: [],
+    scopeName: "global"
+  };
+  errors = [];
+  analyze(ast) {
+    this.walk(ast);
+    return { symbolTable: this.symbolTable, errors: this.errors };
+  }
+  walk(node) {
+    switch (node.type) {
+      case "VAR_DECLARATION" /* VAR_DECLARATION */:
+        this.collectVarDeclaration(node);
+        break;
+      case "ARRAY_DECLARATION" /* ARRAY_DECLARATION */:
+        this.collectArrayDeclaration(node);
+        break;
+      default:
+        node.children?.forEach((child) => this.walk(child));
+        break;
+    }
+  }
+  collectVarDeclaration(node) {
+    const algoType = node.value;
+    const line = node.token?.line ?? 0;
+    const column = node.token?.column ?? 0;
+    for (const child of node.children ?? []) {
+      if (child.type !== "VARIABLE" /* VARIABLE */)
+        continue;
+      const name = child.value;
+      if (this.symbolTable.symbols.has(name)) {
+        this.errors.push({
+          type: "ERROR",
+          message: `La variable '${name}' est déjà déclarée`,
+          line,
+          column,
+          position: node.token?.position ?? 0,
+          code: "DUPLICATE_VARIABLE",
+          explanation: "Chaque variable doit avoir un nom unique dans son scope",
+          suggestion: `Choisissez un autre nom pour la variable '${name}'`
+        });
+      } else {
+        this.defineSymbol(name, algoType, line, column);
+      }
+    }
+  }
+  collectArrayDeclaration(node) {
+    const elemType = node.value;
+    const sizeNode = node.children?.[0];
+    const size = sizeNode?.value;
+    const typeLabel = `TABLEAU[${size}] DE ${elemType}`;
+    const line = node.token?.line ?? 0;
+    const column = node.token?.column ?? 0;
+    for (const child of (node.children ?? []).slice(1)) {
+      if (child.type !== "VARIABLE" /* VARIABLE */)
+        continue;
+      const name = child.value;
+      if (this.symbolTable.symbols.has(name)) {
+        this.errors.push({
+          type: "ERROR",
+          message: `La variable '${name}' est déjà déclarée`,
+          line,
+          column,
+          position: node.token?.position ?? 0,
+          code: "DUPLICATE_VARIABLE",
+          explanation: "Chaque variable doit avoir un nom unique dans son scope",
+          suggestion: `Choisissez un autre nom pour la variable '${name}'`
+        });
+      } else {
+        this.defineSymbol(name, typeLabel, line, column);
+      }
+    }
+  }
+  defineSymbol(name, type, line, column) {
+    const info = {
+      name,
+      type,
+      scope: this.symbolTable.scopeName,
+      line,
+      column
+    };
+    this.symbolTable.symbols.set(name, info);
+  }
+}
+
 // src/parser/parser.ts
 class Parser {
   tokens;
   current = 0;
   errors = [];
-  symbolTable;
-  reservedKeywords = new Set([
-    "programme",
-    "debut",
-    "fin",
-    "var",
-    "entier",
-    "reel",
-    "booleen",
-    "chaine",
-    "si",
-    "alors",
-    "sinon",
-    "finsi",
-    "tantque",
-    "faire",
-    "fintantque",
-    "pour",
-    "a",
-    "finpour",
-    "repeter",
-    "jusqua",
-    "lire",
-    "ecrire",
-    "vrai",
-    "faux",
-    "et",
-    "ou",
-    "non",
-    "fonction",
-    "procedure",
-    "retourner"
-  ]);
+  reservedKeywords = new Set(Object.entries(KEYWORDS).filter(([, e]) => e.tokenType !== null).map(([label]) => label.toLowerCase()));
   constructor(tokens) {
     this.tokens = tokens;
-    this.symbolTable = {
-      symbols: new Map,
-      children: [],
-      scopeName: "global"
-    };
   }
   isReservedKeyword(identifier) {
     return this.reservedKeywords.has(identifier.toLowerCase());
   }
   isKeywordToken(tokenType) {
-    return [
-      "PROGRAMME" /* PROGRAM */,
-      "DEBUT" /* BEGIN */,
-      "FIN" /* END */,
-      "VAR" /* VAR */,
-      "ENTIER" /* INTEGER */,
-      "REEL" /* REAL */,
-      "BOOLEEN" /* BOOLEAN */,
-      "CHAINE" /* STRING */,
-      "SI" /* IF */,
-      "ALORS" /* THEN */,
-      "SINON" /* ELSE */,
-      "TANTQUE" /* WHILE */,
-      "FAIRE" /* DO */,
-      "POUR" /* FOR */,
-      "ALLANT" /* ALLANT */,
-      "DE" /* DE */,
-      "A" /* TO */,
-      "REPETER" /* REPEAT */,
-      "JUSQUA" /* UNTIL */,
-      "LIRE" /* READ */,
-      "ECRIRE" /* WRITE */,
-      "VRAI" /* TRUE */,
-      "FAUX" /* FALSE */,
-      "ET" /* AND */,
-      "OU" /* OR */,
-      "NON" /* NOT */,
-      "FINPOUR" /* ENDFOR */,
-      "FINIF" /* ENDIF */,
-      "FINTANTQUE" /* ENDWHILE */
-    ].includes(tokenType);
+    return Object.values(KEYWORDS).some((e) => e.tokenType === tokenType);
   }
   createReservedKeywordError(identifier, token) {
     this.errors.push({
@@ -3050,30 +3308,22 @@ class Parser {
     });
   }
   parse() {
+    let ast;
     try {
-      const program2 = this.parseProgram();
-      return {
-        ast: program2,
-        errors: this.errors,
-        symbolTable: this.symbolTable
-      };
+      ast = this.parseProgram();
     } catch (error) {
-      return {
-        ast: { type: "PROGRAM" /* PROGRAM */, children: [] },
-        errors: [
-          ...this.errors,
-          {
-            type: "ERROR",
-            message: error instanceof Error ? error.message : "Erreur de parsing inconnue",
-            line: 1,
-            column: 1,
-            position: 0,
-            code: "PARSE_ERROR"
-          }
-        ],
-        symbolTable: this.symbolTable
-      };
+      ast = { type: "PROGRAM" /* PROGRAM */, children: [] };
+      this.errors.push({
+        type: "ERROR",
+        message: error instanceof Error ? error.message : "Erreur de parsing inconnue",
+        line: 1,
+        column: 1,
+        position: 0,
+        code: "PARSE_ERROR"
+      });
     }
+    const { symbolTable, errors: semanticErrors } = new SemanticAnalyzer().analyze(ast);
+    return { ast, errors: [...this.errors, ...semanticErrors], symbolTable };
   }
   parseProgram() {
     const programToken = this.expect("PROGRAMME" /* PROGRAM */, 'Le programme doit commencer par le mot-clé "programme"');
@@ -3089,17 +3339,25 @@ class Parser {
   }
   parseBlock() {
     const declarations = this.parseDeclarations();
+    const subprograms = [];
+    while (this.check(["FONCTION" /* FUNCTION */, "PROCEDURE" /* PROCEDURE */])) {
+      if (this.check("FONCTION" /* FUNCTION */)) {
+        subprograms.push(this.parseFunctionDeclaration());
+      } else {
+        subprograms.push(this.parseProcedureDeclaration());
+      }
+    }
     const compoundStatement = this.parseCompoundStatement();
     return {
       type: "BLOCK" /* BLOCK */,
-      children: [declarations, compoundStatement]
+      children: [declarations, ...subprograms, compoundStatement]
     };
   }
   parseDeclarations() {
     const declarations = [];
     while (this.check("VAR" /* VAR */)) {
       this.advance();
-      while (!this.check("DEBUT" /* BEGIN */) && !this.isAtEnd()) {
+      while (!this.check("DEBUT" /* BEGIN */) && !this.check("FONCTION" /* FUNCTION */) && !this.check("PROCEDURE" /* PROCEDURE */) && !this.isAtEnd()) {
         const declaration = this.parseVariableDeclaration();
         declarations.push(declaration);
         if (!this.check("SEMICOLON" /* SEMICOLON */)) {
@@ -3140,31 +3398,27 @@ class Parser {
       }
     } while (true);
     this.expect("COLON" /* COLON */, "Deux-points attendus après les identificateurs");
+    if (this.check("TABLEAU" /* ARRAY */)) {
+      this.advance();
+      this.expect("LEFT_BRACKET" /* LEFT_BRACKET */, '"[" attendu après TABLEAU');
+      const sizeToken = this.expect("NUMBER" /* NUMBER */, "Taille du tableau attendue");
+      this.expect("RIGHT_BRACKET" /* RIGHT_BRACKET */, '"]" attendu après la taille du tableau');
+      this.expect("DE" /* DE */, '"DE" attendu après la taille du tableau');
+      const elemTypeToken = this.expect(["ENTIER" /* INTEGER */, "REEL" /* REAL */, "BOOLEEN" /* BOOLEAN */, "CHAINE" /* STRING */], "Type des éléments du tableau attendu");
+      const elemType = this.tokenTypeToDataType(elemTypeToken.type);
+      const size = parseInt(sizeToken.value);
+      return {
+        type: "ARRAY_DECLARATION" /* ARRAY_DECLARATION */,
+        value: elemType,
+        children: [
+          { type: "LITERAL" /* LITERAL */, value: size },
+          ...identifiers.map((name) => ({ type: "VARIABLE" /* VARIABLE */, value: name }))
+        ],
+        token: elemTypeToken
+      };
+    }
     const typeToken = this.expect(["ENTIER" /* INTEGER */, "REEL" /* REAL */, "BOOLEEN" /* BOOLEAN */, "CHAINE" /* STRING */], "Type de variable attendu");
     const type = this.tokenTypeToDataType(typeToken.type);
-    for (const identifier of identifiers) {
-      if (this.symbolTable.symbols.has(identifier)) {
-        this.errors.push({
-          type: "ERROR",
-          message: `La variable '${identifier}' est déjà déclarée`,
-          line: typeToken.line,
-          column: typeToken.column,
-          position: typeToken.position,
-          code: "DUPLICATE_VARIABLE",
-          explanation: "Chaque variable doit avoir un nom unique dans son scope",
-          suggestion: `Choisissez un autre nom pour la variable '${identifier}'`
-        });
-      } else {
-        const symbolInfo = {
-          name: identifier,
-          type,
-          scope: this.symbolTable.scopeName,
-          line: typeToken.line,
-          column: typeToken.column
-        };
-        this.symbolTable.symbols.set(identifier, symbolInfo);
-      }
-    }
     return {
       type: "VAR_DECLARATION" /* VAR_DECLARATION */,
       value: type,
@@ -3181,9 +3435,16 @@ class Parser {
     while (!this.check("FIN" /* END */) && !this.isAtEnd()) {
       const statement = this.parseStatement();
       statements.push(statement);
+      const isBlockStatement = [
+        "IF_STATEMENT" /* IF_STATEMENT */,
+        "WHILE_STATEMENT" /* WHILE_STATEMENT */,
+        "FOR_STATEMENT" /* FOR_STATEMENT */,
+        "REPEAT_STATEMENT" /* REPEAT_STATEMENT */,
+        "COMPOUND_STATEMENT" /* COMPOUND_STATEMENT */
+      ].includes(statement.type);
       if (this.check("SEMICOLON" /* SEMICOLON */)) {
         this.advance();
-      } else if (!this.check("FIN" /* END */) && !this.check("FINIF" /* ENDIF */) && !this.check("FINTANTQUE" /* ENDWHILE */)) {
+      } else if (!isBlockStatement && !this.check("FIN" /* END */) && !this.check("FINIF" /* ENDIF */) && !this.check("FINTANTQUE" /* ENDWHILE */) && !this.check("FINPOUR" /* ENDFOR */)) {
         this.errors.push({
           type: "ERROR",
           message: "Point-virgule attendu après l'instruction",
@@ -3226,6 +3487,16 @@ class Parser {
     if (this.check("ECRIRE" /* WRITE */)) {
       return this.parseWriteStatement();
     }
+    if (this.check("RETOURNER" /* RETURN */)) {
+      return this.parseReturnStatement();
+    }
+    if (this.check("IDENTIFIER" /* IDENTIFIER */) && this.peekAhead(1)?.type === "LEFT_PAREN" /* LEFT_PAREN */) {
+      const nameToken = this.advance();
+      return this.parseFunctionCall(nameToken);
+    }
+    if (this.check("IDENTIFIER" /* IDENTIFIER */) && this.peekAhead(1)?.type === "LEFT_BRACKET" /* LEFT_BRACKET */) {
+      return this.parseArrayAssignment();
+    }
     return this.parseAssignment();
   }
   parseIfStatement(isElseIf = false) {
@@ -3345,14 +3616,23 @@ class Parser {
   parseReadStatement() {
     const readToken = this.advance();
     this.expect("LEFT_PAREN" /* LEFT_PAREN */, 'Parenthèse ouvrante attendue après "lire"');
-    let variable;
+    let target;
     if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
-      variable = this.advance();
+      const variable = this.advance();
+      if (this.check("LEFT_BRACKET" /* LEFT_BRACKET */)) {
+        this.advance();
+        const index = this.parseExpression();
+        this.expect("RIGHT_BRACKET" /* RIGHT_BRACKET */, `"]" attendu après l'index`);
+        target = { type: "ARRAY_ACCESS" /* ARRAY_ACCESS */, value: variable.value, children: [index], token: variable };
+      } else {
+        target = { type: "VARIABLE" /* VARIABLE */, value: variable.value, token: variable };
+      }
     } else {
       const currentToken = this.peek();
       if (this.isKeywordToken(currentToken.type)) {
-        variable = this.advance();
+        const variable = this.advance();
         this.createReservedKeywordError(variable.value, variable);
+        target = { type: "VARIABLE" /* VARIABLE */, value: variable.value, token: variable };
       } else {
         this.expect("IDENTIFIER" /* IDENTIFIER */, 'Variable attendue dans "lire"');
         throw new Error('Variable attendue dans "lire"');
@@ -3361,9 +3641,7 @@ class Parser {
     this.expect("RIGHT_PAREN" /* RIGHT_PAREN */, 'Parenthèse fermante attendue dans "lire"');
     return {
       type: "READ_STATEMENT" /* READ_STATEMENT */,
-      children: [
-        { type: "VARIABLE" /* VARIABLE */, value: variable.value, token: variable }
-      ],
+      children: [target],
       token: readToken
     };
   }
@@ -3491,7 +3769,7 @@ class Parser {
   }
   parseMultiplicativeExpression() {
     let left = this.parseUnaryExpression();
-    while (this.check(["MULTIPLY" /* MULTIPLY */, "DIVIDE" /* DIVIDE */])) {
+    while (this.check(["MULTIPLY" /* MULTIPLY */, "DIVIDE" /* DIVIDE */, "MODULO" /* MODULO */])) {
       const operator = this.advance();
       const right = this.parseUnaryExpression();
       left = {
@@ -3540,7 +3818,7 @@ class Parser {
       const token2 = this.advance();
       return {
         type: "LITERAL" /* LITERAL */,
-        value: token2.value === "vrai",
+        value: token2.value.toLowerCase() === "vrai",
         token: token2
       };
     }
@@ -3554,6 +3832,20 @@ class Parser {
     }
     if (this.check("IDENTIFIER" /* IDENTIFIER */)) {
       const token2 = this.advance();
+      if (this.check("LEFT_PAREN" /* LEFT_PAREN */)) {
+        return this.parseFunctionCall(token2);
+      }
+      if (this.check("LEFT_BRACKET" /* LEFT_BRACKET */)) {
+        this.advance();
+        const index = this.parseExpression();
+        this.expect("RIGHT_BRACKET" /* RIGHT_BRACKET */, `"]" attendu après l'index`);
+        return {
+          type: "ARRAY_ACCESS" /* ARRAY_ACCESS */,
+          value: token2.value,
+          children: [index],
+          token: token2
+        };
+      }
       if (this.isReservedKeyword(token2.value)) {
         this.createReservedKeywordError(token2.value, token2);
       }
@@ -3597,14 +3889,14 @@ class Parser {
   parseRepeatStatement() {
     const repeatToken = this.advance();
     const statements = [];
-    while (!this.check("JUSQUA" /* UNTIL */) && !this.isAtEnd()) {
+    while (!this.check("JUSQU'A" /* UNTIL */) && !this.isAtEnd()) {
       const statement = this.parseStatement();
       statements.push(statement);
       if (this.check("SEMICOLON" /* SEMICOLON */)) {
         this.advance();
       }
     }
-    this.expect("JUSQUA" /* UNTIL */, '"jusqua" attendu à la fin de la boucle repeter');
+    this.expect("JUSQU'A" /* UNTIL */, `"jusqu'a" attendu à la fin de la boucle repeter`);
     const condition = this.parseExpression();
     return {
       type: "REPEAT_STATEMENT" /* REPEAT_STATEMENT */,
@@ -3612,6 +3904,127 @@ class Parser {
       token: repeatToken
     };
   }
+  parseFunctionCall(nameToken) {
+    this.advance();
+    const args = [];
+    if (!this.check("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+      args.push(this.parseExpression());
+      while (this.check("COMMA" /* COMMA */)) {
+        this.advance();
+        args.push(this.parseExpression());
+      }
+    }
+    this.expect("RIGHT_PAREN" /* RIGHT_PAREN */, '")` attendu après les arguments');
+    return {
+      type: "FUNCTION_CALL" /* FUNCTION_CALL */,
+      value: nameToken.value,
+      children: args,
+      token: nameToken
+    };
+  }
+  parseArrayAssignment() {
+    const nameToken = this.advance();
+    this.advance();
+    const index = this.parseExpression();
+    this.expect("RIGHT_BRACKET" /* RIGHT_BRACKET */, `"]" attendu après l'index`);
+    this.expect("ASSIGN" /* ASSIGN */, `":=" attendu dans l'affectation`);
+    const value = this.parseExpression();
+    return {
+      type: "ASSIGNMENT" /* ASSIGNMENT */,
+      children: [
+        { type: "ARRAY_ACCESS" /* ARRAY_ACCESS */, value: nameToken.value, children: [index], token: nameToken },
+        value
+      ],
+      token: nameToken
+    };
+  }
+  parseReturnStatement() {
+    const token = this.advance();
+    const expr = this.parseExpression();
+    return {
+      type: "RETURN_STATEMENT" /* RETURN_STATEMENT */,
+      children: [expr],
+      token
+    };
+  }
+  parseParameterList() {
+    this.expect("LEFT_PAREN" /* LEFT_PAREN */, '"(" attendu dans la déclaration');
+    const params = [];
+    if (!this.check("RIGHT_PAREN" /* RIGHT_PAREN */)) {
+      params.push(this.parseParameter());
+      while (this.check("SEMICOLON" /* SEMICOLON */) || this.check("COMMA" /* COMMA */)) {
+        this.advance();
+        if (this.check("RIGHT_PAREN" /* RIGHT_PAREN */))
+          break;
+        params.push(this.parseParameter());
+      }
+    }
+    this.expect("RIGHT_PAREN" /* RIGHT_PAREN */, '")" attendu après les paramètres');
+    return { type: "PARAMETER_LIST" /* PARAMETER_LIST */, children: params };
+  }
+  parseParameter() {
+    const nameToken = this.expect("IDENTIFIER" /* IDENTIFIER */, "Nom de paramètre attendu");
+    this.expect("COLON" /* COLON */, '":" attendu après le nom du paramètre');
+    if (this.check("TABLEAU" /* ARRAY */)) {
+      this.advance();
+      let size;
+      if (this.check("LEFT_BRACKET" /* LEFT_BRACKET */)) {
+        this.advance();
+        const sizeToken = this.expect("NUMBER" /* NUMBER */, "Taille attendue");
+        this.expect("RIGHT_BRACKET" /* RIGHT_BRACKET */, '"]" attendu');
+        size = parseInt(sizeToken.value);
+      }
+      this.expect("DE" /* DE */, '"DE" attendu après TABLEAU');
+      const elemTypeToken = this.expect(["ENTIER" /* INTEGER */, "REEL" /* REAL */, "BOOLEEN" /* BOOLEAN */, "CHAINE" /* STRING */], "Type des éléments attendu");
+      const elemType = this.tokenTypeToDataType(elemTypeToken.type);
+      const typeLabel = size !== undefined ? `TABLEAU[${size}] DE ${elemType}` : `TABLEAU DE ${elemType}`;
+      return {
+        type: "PARAMETER" /* PARAMETER */,
+        value: nameToken.value,
+        token: nameToken,
+        symbolInfo: { name: nameToken.value, type: typeLabel, scope: "param" }
+      };
+    }
+    const typeToken = this.expect(["ENTIER" /* INTEGER */, "REEL" /* REAL */, "BOOLEEN" /* BOOLEAN */, "CHAINE" /* STRING */], "Type du paramètre attendu");
+    const paramType = this.tokenTypeToDataType(typeToken.type);
+    return {
+      type: "PARAMETER" /* PARAMETER */,
+      value: nameToken.value,
+      token: nameToken,
+      symbolInfo: { name: nameToken.value, type: paramType, scope: "param" }
+    };
+  }
+  parseFunctionDeclaration() {
+    const token = this.advance();
+    const nameToken = this.expect("IDENTIFIER" /* IDENTIFIER */, "Nom de fonction attendu");
+    const paramList = this.parseParameterList();
+    this.expect("COLON" /* COLON */, '":" attendu pour le type de retour');
+    const retTypeToken = this.expect(["ENTIER" /* INTEGER */, "REEL" /* REAL */, "BOOLEEN" /* BOOLEAN */, "CHAINE" /* STRING */], "Type de retour attendu");
+    const retType = this.tokenTypeToDataType(retTypeToken.type);
+    const body = this.parseCompoundStatement();
+    return {
+      type: "FUNCTION_DECLARATION" /* FUNCTION_DECLARATION */,
+      value: nameToken.value,
+      children: [
+        paramList,
+        { type: "TYPE_SPECIFIER" /* TYPE_SPECIFIER */, value: retType },
+        body
+      ],
+      token
+    };
+  }
+  parseProcedureDeclaration() {
+    const token = this.advance();
+    const nameToken = this.expect("IDENTIFIER" /* IDENTIFIER */, "Nom de procédure attendu");
+    const paramList = this.parseParameterList();
+    const body = this.parseCompoundStatement();
+    return {
+      type: "PROCEDURE_DECLARATION" /* PROCEDURE_DECLARATION */,
+      value: nameToken.value,
+      children: [paramList, body],
+      token
+    };
+  }
   check(type) {
     if (this.isAtEnd())
       return false;
@@ -3761,6 +4174,8 @@ class CodeGenerator {
         return this.generateBlock(node);
       case "VAR_DECLARATION":
         return this.generateVariableDeclaration(node);
+      case "ARRAY_DECLARATION":
+        return this.generateArrayDeclaration(node);
       case "COMPOUND_STATEMENT":
         return this.generateCompoundStatement(node);
       case "ASSIGNMENT":
@@ -3777,6 +4192,12 @@ class CodeGenerator {
         return this.generateReadStatement(node);
       case "WRITE_STATEMENT":
         return this.generateWriteStatement(node);
+      case "FUNCTION_DECLARATION":
+        return this.generateFunctionDeclaration(node);
+      case "PROCEDURE_DECLARATION":
+        return this.generateProcedureDeclaration(node);
+      case "RETURN_STATEMENT":
+        return this.generateReturnStatement(node);
       case "BINARY_OP":
         return this.generateBinaryOp(node);
       case "UNARY_OP":
@@ -3785,6 +4206,10 @@ class CodeGenerator {
         return this.generateLiteral(node);
       case "VARIABLE":
         return this.generateVariable(node);
+      case "ARRAY_ACCESS":
+        return this.generateArrayAccess(node);
+      case "FUNCTION_CALL":
+        return this.generateFunctionCall(node);
       default:
         this.errors.push({
           type: "ERROR",
@@ -3799,14 +4224,25 @@ class CodeGenerator {
   }
   generateProgram(node) {
     const lines = [];
+    const block = node.children?.[0];
     lines.push(`// Programme: ${node.value}`);
+    if (block?.children) {
+      for (const child of block.children) {
+        if (child.type === "FUNCTION_DECLARATION" || child.type === "PROCEDURE_DECLARATION") {
+          lines.push(this.generateNode(child));
+          lines.push("");
+        }
+      }
+    }
     lines.push("async function main() {");
     this.indentLevel++;
-    if (node.children && node.children.length > 0) {
-      for (const child of node.children) {
-        const childCode = this.generateNode(child);
-        if (childCode) {
-          lines.push(this.indent(childCode));
+    if (block?.children) {
+      for (const child of block.children) {
+        if (child.type !== "FUNCTION_DECLARATION" && child.type !== "PROCEDURE_DECLARATION") {
+          const childCode = this.generateNode(child);
+          if (childCode) {
+            lines.push(this.indent(childCode));
+          }
         }
       }
     }
@@ -3844,7 +4280,8 @@ class CodeGenerator {
       for (const child of node.children) {
         const childCode = this.generateNode(child);
         if (childCode) {
-          lines.push(this.indent(childCode));
+          const stmt = child.type === "FUNCTION_CALL" ? childCode.replace(/^\(|\)$/g, "") + ";" : childCode;
+          lines.push(this.indent(stmt));
         }
       }
     }
@@ -3855,15 +4292,107 @@ class CodeGenerator {
     if (!node.children || node.children.length < 2) {
       return "";
     }
-    const variable = node.children[0];
+    const target = node.children[0];
     const expression = node.children[1];
-    if (!variable || !expression) {
+    if (!target || !expression) {
       return "";
     }
-    const variableName = variable.value;
     const expressionCode = this.generateNode(expression);
+    if (target.type === "ARRAY_ACCESS") {
+      const arrayName = target.value;
+      const index = this.generateNode(target.children[0]);
+      return `${arrayName}[${index}] = ${expressionCode};`;
+    }
+    const variableName = target.value;
     return `${variableName} = ${expressionCode};`;
   }
+  generateArrayDeclaration(node) {
+    if (!node.children || node.children.length < 2)
+      return "";
+    const size = node.children[0].value;
+    const elemType = node.value;
+    const defaultValue = elemType === "BOOLEEN" ? "false" : elemType === "CHAINE" ? '""' : "0";
+    const names = node.children.slice(1).map((c) => c.value);
+    return names.map((name) => `let ${name} = new Array(${size}).fill(${defaultValue});`).join(`
+`);
+  }
+  generateArrayAccess(node) {
+    const name = node.value;
+    const index = this.generateNode(node.children[0]);
+    return `${name}[${index}]`;
+  }
+  generateFunctionCall(node) {
+    const name = node.value;
+    const args = (node.children ?? []).map((c) => {
+      const code = this.generateNode(c);
+      if (c.type === "VARIABLE") {
+        const sym = this.symbolTable.symbols.get(c.value);
+        if (sym?.type?.startsWith("TABLEAU"))
+          return `${code}.slice()`;
+      }
+      return code;
+    });
+    switch (name.toLowerCase()) {
+      case "abs":
+        return `Math.abs(${args[0]})`;
+      case "max":
+        return `Math.max(${args.join(", ")})`;
+      case "min":
+        return `Math.min(${args.join(", ")})`;
+      case "mod":
+        return `(${args[0]} % ${args[1]})`;
+      case "racine_carree":
+        return `Math.sqrt(${args[0]})`;
+      case "taille":
+        return `${args[0]}.length`;
+      case "sous_chaine":
+        return `${args[0]}.substring(${args[1]}, ${args[1]} + ${args[2]})`;
+      case "concat":
+        return args.join(" + ");
+      case "entier_en_reel":
+        return `${args[0]}`;
+      case "reel_en_entier":
+        return `Math.trunc(${args[0]})`;
+      default:
+        return `(await ${name}(${args.join(", ")}))`;
+    }
+  }
+  generateFunctionDeclaration(node) {
+    const name = node.value;
+    const [paramList, , body] = node.children ?? [];
+    const params = this.generateParamList(paramList);
+    const bodyCode = this.generateNode(body);
+    const lines = [`async function ${name}(${params}) {`];
+    this.indentLevel++;
+    lines.push(this.indent(bodyCode));
+    this.indentLevel--;
+    lines.push("}");
+    return lines.join(`
+`);
+  }
+  generateProcedureDeclaration(node) {
+    const name = node.value;
+    const [paramList, body] = node.children ?? [];
+    const params = this.generateParamList(paramList);
+    const bodyCode = this.generateNode(body);
+    const lines = [`async function ${name}(${params}) {`];
+    this.indentLevel++;
+    lines.push(this.indent(bodyCode));
+    this.indentLevel--;
+    lines.push("}");
+    return lines.join(`
+`);
+  }
+  generateParamList(paramList) {
+    if (!paramList?.children)
+      return "";
+    return paramList.children.map((p) => p.value).join(", ");
+  }
+  generateReturnStatement(node) {
+    if (!node.children?.[0])
+      return "return;";
+    return `return ${this.generateNode(node.children[0])};`;
+  }
   generateIfStatement(node) {
     if (!node.children || node.children.length < 2) {
       return "";
@@ -3965,34 +4494,20 @@ class CodeGenerator {
     return code;
   }
   generateReadStatement(node) {
-    if (!node.children || node.children.length === 0) {
+    if (!node.children || node.children.length === 0)
       return "";
-    }
-    const variable = node.children[0];
-    if (!variable) {
+    const target = node.children[0];
+    if (!target)
       return "";
+    const isArray = target.type === "ARRAY_ACCESS";
+    const varName = isArray ? `${target.value}[${this.generateNode(target.children[0])}]` : target.value;
+    const symbolName = target.value;
+    const symbolInfo = this.symbolTable.symbols.get(symbolName);
+    const typeHint = symbolInfo?.type ?? "";
+    if (typeHint.startsWith("ENTIER") || typeHint === "REEL" || typeHint.startsWith("TABLEAU")) {
+      return `${varName} = parseInt(await lire(""));`;
     }
-    const variableName = variable.value;
-    const symbolInfo = this.symbolTable.symbols.get(variableName);
-    let conversion = "";
-    if (symbolInfo) {
-      switch (symbolInfo.type) {
-        case "ENTIER":
-        case "REEL":
-          conversion = "parseInt(";
-          break;
-        case "BOOLEEN":
-          conversion = "(";
-          break;
-        default:
-          conversion = "";
-      }
-    }
-    if (conversion) {
-      return `${variableName} = ${conversion}await lire(""));`;
-    } else {
-      return `${variableName} = await lire("");`;
-    }
+    return `${varName} = await lire("");`;
   }
   generateWriteStatement(node) {
     if (!node.children || node.children.length === 0) {
@@ -4091,6 +4606,8 @@ class CodeGenerator {
         return ">";
       case ">=":
         return ">=";
+      case "%":
+        return "%";
       case "et":
         return "&&";
       case "ou":