c-repl/soutenance.md

# Rapport C-repl en C++

## Architecture

### Lexer (Alaric, lexer.cpp)

Première étape de l'interprétation du langage. Le code à l'état brut est transformé en un tableau de tokens.
Le lexer avance dans le texte en essayant de matcher chaque type de token, parfois à l'aide de `regex`, dans un ordre bien choisi.
Lors de cette étape, les constantes littérales sont d'ores et déjà parsées et stockées dans leur type interne.


### Parsing (Augustin, parser.cpp)

Le parser transforme le tableau de tokens en un `AST (Abstract Syntax Tree)`.
Il procède par backtracking en suivant les règles de la grammaire définie dans `types.hpp`.


### Analyse statique (Augustin, analysis.cpp)

Avant d'exécuter le programme, cette étape infère le type de chacun des éléments du programme (stocké sous forme d'`AST`) et vérifie la validité de chaque opération.

Une "mémoire virtuelle", copie affaiblie de la mémoire actuelle de la repl, sert à stocker les types des variables.
Le type de chaque noeud de l'`AST` est calculé récursivement puis la validité des types passés aux opérateurs est vérifiée,
en s'appuyant notamment sur les règles de casting définies dans `casting.cpp`.


### Évaluation (Alaric, eval.cpp)

Les noeuds de l'`AST` sont évalués de manière récursive.
Des exceptions sont utilisées en interne pour traiter les instructions `break`, `continue` et `return`.


### Mémoire (Alaric, memory.cpp)

`Memory` définit une structure de mémoire réutilisable qui sert lors de l'analyse statique et de l'évaluation.
Elle gère notamment les `scopes`.


#### Types (types.hpp)

Rassemble les définitions de type communes à tout le projet.


#### Execute (execute.cpp)

Encapsule toutes les étapes de l'interprétation du code brut aux résultats.


#### Lecture de l'entrée (main.c, input.c)

Gère le traitement des arguments en ligne de commande et l'interface utilisateur de la repl: la partie "interactive" de la repl.


#### Casting (casting.cpp)

Définit les règles de casting entre les types.


#### Erreurs (errors.cpp)

Définit les erreurs, leur affichage.


#### Utilitaires (utils.cpp, debug.cpp)

Fonctions utilitaires et de débogage.


## Appropriation

Certaines parties du langage C ne sont pas spécifiées dans le standard et varient ainsi d'un compilateur à l'autre. Nous avons parfois fait des choix arbitraires, en privilégiant l'option la plus naturelle.

La repl ne permet pas les `undefined behavior` dans la mesure où ceux-ci sont protégés par le C++.
Par exemple, il n'est pas possible de lire une variable non-initialisée: cela produira une erreur.

Il a été choisi que toute instruction ait une valeur et un type. Cela permet d'afficher une valeur de retour à l'utilisateur lorsqu'il entre une ou plusieurs instructions.
Pour les `statements`, ce type est toujours `void`, représenté en interne par la valeur `monostate`. Cependant, certaines `expression-statements` peuvent avoir un type non-`void`. Les `expressions` ont évidemment une valeur.


## Features

### Types

Les types `int`, `double`, `void` et les fonctions composées de ces mêmes types sont supportés.


### Instructions

Les instructions suivantes sont implémentées:

- Opérateurs arithmétiques binaires (`+`, `-`, `*`, `/`, `%`) et unaires (`+`, `-`)
- Opérateurs logiques (`&&`, `||`, `!`)
- Opérateurs de comparaison génériques (`==`, `!=`)
- Opérateurs de comparaison arithmétique (`<=`, `<`, `>=`, `>`)
- Opérateurs d'incrémentation gauche et droite (`++`, `--`)
- Opérateur virgule (`,`)
- Déclarations de variables avec et sans initialisation (`int x;`, `int x = 1;`)
- Assignation de variables (`x = 1`)
- Conditionnelles (`if (..) ..`, `if (..) .. else (..) ..`)
- Boucles (`for`, `while`) avec contrôle (`break`, `continue`)
- Définition de blocs (`{}`)
- Déclaration de fonctions avec et sans corps (`int foo(int x);`, `int foo(int x) { .. };`)
- Appels de fonctions (`foo(1)`)


### Scopes et closures

L'interpréteur prend en charge les `scopes` de bloc et de fonction, ainsi que pour les `for`, comme attendu dans le langage C.
Il gère également les `closures` comme il se doit dans un langage impératif non-fonctionnel.
Une implémentation qui convient à ce type langage (mais pas aux langages multi-paradigmes) est une tableau de pointeurs.


### Contrôle de flot

La repl ne comporte pas de contrôle de flot avant l'évaluation-même de l'AST.
En conséquence, les erreurs associées sont détectées à la volée lors de l'évaluation.


### Erreurs

La repl comporte un système d'erreur riche avec messages d'erreur et position dans le code.
Celles-ci sont divisées en 4 catégories en fonction de l'étape à laquelle elles interviennent:

- `SyntaxError`: lexer et parsing
- `ControlError`: en raison de l'absence de contrôle de flot préalable, à divers endroits
- `TypeError`: analyse statique
- `RuntimeError`: évaluation

Les `RuntimeErrors` sont accompagnées d'une `stack trace` contenant la position dans le code des appels de fonction récursifs.


### Librairie standard

Les fonctions suivantes sont proposées pour interagir directement avec la repl:

- `clear_memory()` réinitialise la mémoire (non supporté hors de la scope globale)
- `dump_memory()` affiche l'état actuel de la mémoire
- `dump_history()` affiche l'historique du code passé en entrée


### Interface utilisateur

Le système d'entrée est pratique : il permet de se déplacer dans la ligne actuelle et de naviguer dans l'historique du code entré.
Les lignes sont automatiquement numérotées pendant que la saisie.
Pour permettre les sauts de ligne multiples, il est nécessaire de taper `;;` pour indiquer au programme que l'on a terminé son entrée.
Le résultat de l'évaluation du programme est alors affiché.


## Tests

Une suite de tests automatisée est disponible : elle teste les différentes parties du code, les fonctionnalités du langage ainsi que chaque type d'erreur.
Des programmes plus conséquents sont disponibles dans `./example`.