change nom dev doc anglais et fr et ajoute noms du groupe dans readme

Author: simonperrigault

devdoc.md

@@ -4,6 +4,15 @@
 
 The IFCC compiler is a compiler for a subset of the C programming language. It handles x86_64 and WebAssembly (WASM) architectures. It uses our own IR (Intermediate Representation) to help handle the compilation process with the different architectures and optimizations.
 
+## Group
+
+- PALISSER Eugénie
+- GOUINEAUD Romane
+- MUHULET Mathias
+- SAMAIN Luc
+- JOUSSOT-DUBIEN Gabin
+- PERRIGAULT Simon
+
 ## Build
 
 To build the IFCC compiler, go to the `compiler` directory and use the following command:

readme.md

@@ -1,177 +1,40 @@
-# Documentation du Compilateur IFCC
+# Execution
+The roles of the visitors are described in the next sections
 
-## Vue d'ensemble
+1. Parse the arguments
+2. Tokenize and parse the input program
+3. ContinueBreakVisitor
+4. SymbolTableVisitor
+5. TypeCheckVisitor
+6. IRGenVisitor
+7. Generate the backend code
 
-Le compilateur IFCC est un compilateur pour un sous-ensemble du langage C, développé comme projet pédagogique. Il utilise une approche basée sur la génération de code intermédiaire (IR) puis la traduction en code assembleur x86 et WebAssembly (WAT).
+## Parse the arguments
+We have a simple command line argument parser. It takes the following arguments:
+- `-o <output_file>`: Specify the output file name
+- `-v`: Enable verbose mode, which print the symbol table in the output
+- `-h`: Show help message
+- `-w`: Generate WebAssembly code instead of x86_64
+- `<source_file.c>`: The input C source file to be compiled
 
-## Flux d'exécution
+## Tokenize and parse the input program
+The input program is tokenized and parsed using ANTLR4. The parser generates a parse tree according to our grammar written in `ifcc.g4`, which is then traversed by the visitors to perform various tasks.
 
-Le compilateur suit les étapes suivantes :
+## ContinueBreakVisitor
+The `ContinueBreakVisitor` is responsible for checking the usage of `continue` and `break` statements in loops. It ensures that these statements are only used inside loops. If a `continue` or `break` statement is found outside of its valid context, an error is reported.
 
-1. Parse des arguments de la ligne de commande
-2. Tokenisation et analyse syntaxique du programme d'entrée
-3. Vérification des instructions `break` et `continue` avec ContinueBreakVisitor
-4. Construction de la table des symboles avec SymbolTableVisitor
-5. Vérification des types avec TypeCheckVisitor
-6. Génération de la représentation intermédiaire avec IRGenVisitor
-7. Génération du code cible (x86_64 ou WebAssembly)
+## SymbolTableVisitor
+The `SymbolTableVisitor` is responsible for creating the symbol table. It traverses the parse tree and collects information about variables, functions, and their types. It computes the adresses of the variables and also handles the scoping rules, ensuring that variables are declared and used in the correct scope. Finally, it checks that the function calls are valid and that the arguments passed to the functions match their definitions.
 
-![image](pictures/schema_execution.png)
+## TypeCheckVisitor
+The `TypeCheckVisitor` is responsible for checking the types of expressions and statements in the program. It ensures that the types are compatible and that operations are performed on the correct types. It also checks for type errors, such as assigning a value of one type to a variable of another incompatible type. It writes errors if the types are incompatible and warnings if an implicit conversion is done.
 
-## Architecture du Compilateur
+## IRGenVisitor
+The `IRGenVisitor` is responsible for generating the intermediate representation (IR) of the program. It traverses the parse tree and generates IR instructions for each statement and expression. The IR is a representation of the program that is easier to optimize and translate to machine code. The IR is generated in a form that is independent of the target architecture, allowing for easier optimization and code generation. Our IR uses CFG (Control Flow Graph) to represent the flow of control in the program.
 
-L'architecture du compilateur est structurée selon les phases classiques de compilation:
+## Generate the backend code
+The backend code is generated using the CFGs created by the `IRGenVisitor`. The backend code is generated for the target architecture (x86_64 or WebAssembly) and is optimized for performance. The backend code generation is done using a set of rules that translate the IR instructions into the target architecture's assembly language.
 
-1. **Analyse lexicale et syntaxique** : Utilisation d'ANTLR4 pour générer un parseur à partir de la grammaire définie dans `ifcc.g4`.
-2. **Analyse sémantique** : Plusieurs visiteurs parcourent l'AST pour effectuer des vérifications et construire des tables.
-3. **Génération de code intermédiaire** : Transformation de l'AST en représentation intermédiaire.
-4. **Génération de code cible** : Traduction de la représentation intermédiaire en assembleur x86 et WebAssembly.
+# Summary
 
-## Grammaire Supportée
-
-La grammaire définie dans `ifcc.g4` supporte:
-
-- Déclarations et définitions de fonctions
-- Variables et types de base (int, char, double)
-- Expressions arithmétiques et logiques
-- Structures de contrôle (if-else, while)
-- Instructions de saut (break, continue)
-
-## Visiteurs et Analyses
-
-### ContinueBreakCheckVisitor
-- Validation de l'utilisation des instructions `break` et `continue` dans des contextes appropriés
-- Vérifie que ces instructions sont uniquement utilisées à l'intérieur des boucles
-- Signale une erreur si elles sont trouvées en dehors de leur contexte valide
-
-### SymbolTableGenVisitor
-- Construction de la table des symboles
-- Enregistrement des variables avec leur type, offset et portée
-- Enregistrement des fonctions avec leur type et paramètres
-- Vérification des déclarations/utilisations
-- Calcul des adresses des variables en mémoire
-- Gestion des règles de portée (scope)
-- Vérification de la validité des appels de fonction et de la correspondance des arguments
-
-### TypeCheckVisitor
-- Vérification de la cohérence des types dans les expressions
-- Validation des types de retour des fonctions
-- Vérification de compatibilité lors des affectations
-- Signalement d'erreurs si les types sont incompatibles
-- Génération d'avertissements si une conversion implicite est effectuée
-
-### IRGenVisitor
-- Génération d'un code IR indépendant de l'architecture cible
-- Traitement des expressions et conversion en instructions IR
-- Gestion des structures de contrôle (if, while)
-- Construction des blocs de base et du CFG (Control Flow Graph)
-
-## Représentation Intermédiaire
-
-### Structure de l'IR
-- **CFG (Control Flow Graph)** : Représentation du flux de contrôle d'une fonction
-- **BasicBlock** : Suite d'instructions linéaires avec éventuellement un saut à la fin
-- **IRInstr** : Instructions de la représentation intermédiaire
-
-### Types d'Instructions IR
-- Instructions arithmétiques : `Add`, `Sub`, `Mul`, `Div`, `Mod`, `UnaryMinus`
-- Instructions logiques : `And`, `Or`, `Not`
-- Instructions de comparaison : `CompareInt`
-- Instructions de manipulation mémoire : `Rmem`, `Wmem`
-- Instructions de contrôle : `Prologue`, `Epilogue`, `Call`
-- Instructions de chargement : `LdConstInt`, `Copy`
-- Instructions de manipulation des doubles : `DAdd`, `DSub`, `DMul`, `DDiv`, `DUnaryMinus`, `CompareDouble`, `LdConstDouble`, `DRmem`, `DWmem`, `DCopy`, `IntToDouble`, `DoubleToInt`
-
-## Génération de Code
-
-### Code x86-64
-- Génération d'instructions assembleur x86-64 pour Linux
-- Gestion de la pile et des registres
-- Utilisation des conventions d'appel System V AMD64 ABI
-
-### Code WebAssembly
-- Génération de fichiers WAT (WebAssembly Text Format)
-- Support des opérations arithmétiques et logiques
-- Gestion des variables locales et mémoire
-- Implémentation des contrôles de flux équivalents à ceux de x86
-
-## Types Supportés
-
-- `int` (INT32_T)
-- `char` (traité comme INT32_T)
-- `double` (FLOAT64_T)
-
-## Fonctionnalités Avancées
-
-- **Optimisation des constantes** : Évaluation des expressions constantes à la compilation
-- **Gestion des registres virtuels** : Abstraction des registres physiques
-- **Multi-cibles** : Génération de code pour différentes architectures (x86, WebAssembly)
-- **Vérification des erreurs** : Détection d'erreurs sémantiques et rapport
-- **Incréments/décréments** : Support des opérateurs `++` et `--` (préfixés et postfixés)
-- **Opérateurs d'affectation composés** : Support de `+=`, `-=`, `*=`, `/=`, `%=`
-
-## Limitations Connues
-
-- Pas de support pour les structures et unions
-- Pas de support pour les pointeurs
-- Pas de support pour les tableaux
-- Pas d'optimisation avancée
-
-## Options de Ligne de Commande
-
-Le compilateur accepte les options suivantes :
-- `-o <output_file>` : Spécifie le nom du fichier de sortie
-- `-v` : Active le mode verbeux, qui affiche la table des symboles dans la sortie
-- `-h` : Affiche le message d'aide
-- `-w` : Génère du code WebAssembly au lieu de x86_64
-- `<source_file.c>` : Le fichier source C d'entrée à compiler
-
-## Comment Compiler et Exécuter
-
-Pour compiler le projet:
-```bash
-cd compiler
-make
-```
-
-Pour exécuter le compilateur sur un fichier source:
-```bash
-./ifcc input.c -o output.s
-```
-
-Pour générer du WebAssembly:
-```bash
-./ifcc input.c -w -o output.wat
-```
-
-## Tests
-
-Des tests unitaires et d'intégration sont disponibles dans le répertoire `../tests/testfiles/`. Pour exécuter les tests:
-
-```bash
-cd compiler
-make test
-```
-
-Cette commande lance le script Python `../ifcc-test.py` qui exécute tous les tests dans le répertoire `../tests/testfiles/`. Le script vérifie la sortie du compilateur par rapport aux résultats attendus. 
-
-Pour lancer les tests en WebAssembly:
-```bash
-make test-wat 
-```
-
-Cette commande lance le script Python `../ifcc-wat-test.py` qui exécute les tests dans le répertoire `../tests/testfiles/`. Notez que tous les tests ne passent pas en WebAssembly car c'est une version béta qui ne prend pas en charge toutes les fonctionnalités de la version x86. 
-
-Pour lancer des tests en particulier, il est aussi possible de faire la commande : 
-
-```bash
-python3 ifcc-test.py tests/testfiles/01_BasicStructure
-```
-
-Pour lancer l'ensemble des tests sur les structures de bases, par exemple. 
-
-Commande standard : 
-
-```bash
-python3 ifcc-test.py <dossier_ou_fichier_de_test>
-```
+![image](pictures/schema_execution.png)