---
  title: Fichier généré, dans la racine du projet, suite au prompt : "Génère le fichier .md qui facilitera ton travail ultérieurement sur ce projet"
  author: codex
  date: 26 mai 2026
...
# Notes de maintenance

Ce projet est un interpreteur Logo en C++ avec un affichage SFML. Il lit un
fichier `.logo`, le decoupe en tokens, construit un programme interne compose
d'instructions, puis execute ces instructions pas a pas avec une tortue.

## Vue d'ensemble

- `src/main/main.cpp` : point d'entree. Lit les arguments, compile le fichier
  Logo, lance la tortue, execute le programme, puis exporte eventuellement un
  SVG.
- `src/main/Lexer.*` : transforme le texte source en tokens. Les mots-cles
  connus sont declares dans `Lexer.h`.
- `src/main/Program.*` : parse les tokens et construit les instructions. Gere
  aussi les definitions de fonctions `pour ... fin` et les blocs `repete ...
  [ ... ]`.
- `src/main/Instruction.*` : classe de base polymorphe des instructions Logo.
- `src/main/UnaryInstruction.*` : base pratique pour les instructions avec un
  parametre numerique, comme `avance 100`.
- `src/main/Interpreter.*` : execute le programme avec une pile de contextes.
  Cette pile permet les appels de fonctions et les blocs repetes.
- `src/main/ExecutionContext.*` : position courante dans un bloc d'instructions
  et petites variables internes d'execution.
- `src/main/Turtle.*` : etat global de la tortue, affichage SFML, stockage des
  traits et export SVG.

## Instructions existantes

- `Move` : implemente `avance` et `recule`.
- `Turn` : implemente `droite` et `gauche`.
- `SetPenPos` : implemente `leve` et `baisse`.
- `FunctionCall` : appelle une fonction definie avec `pour nom ... fin`.
- `Repeat` : implemente `repete n [ ... ]`.

## Ajouter une commande Logo simple

Pour une commande du type `commande 123` :

1. Ajouter le mot-cle dans `Lexer.h`.
2. Ajouter ce mot-cle au tableau `keywords` dans `Lexer.cpp`.
3. Creer une classe d'instruction, souvent derivee de `UnaryInstruction`.
4. Implementer `doExecute()` et `doDisplay()`.
5. Brancher la commande dans `Program::parseKeyword()`.
6. Ajouter les nouveaux fichiers dans `src/main/CMakeLists.txt`.

## Ajouter une commande avec bloc

Pour une commande du type `motcle ... [ ... ]`, regarder `Repeat`.

`Program` accepte un parametre `bracketDelimited` qui permet de parser un bloc
jusqu'au crochet fermant `]`. L'execution d'un bloc se fait en poussant un
nouveau `ExecutionContext` dans `Interpreter`.

Attention : l'etat dynamique d'une instruction ne doit pas etre stocke dans
l'objet instruction si cette instruction peut etre rejouee. Utiliser plutot
`ExecutionContext::variable()` via `Interpreter::variable()`.

## Export SVG

Chaque trait trace par `turtle::drawLine()` est aussi stocke dans une liste
interne. `turtle::saveSvg(path)` ecrit cette liste dans un fichier SVG avec un
`viewBox="-400 -300 800 600"`, coherent avec la vue SFML actuelle.

Utilisation :

```powershell
logo res/prog2.logo 0 sortie.svg
```

Le troisieme argument est optionnel. Sans lui, le programme garde le
comportement historique et affiche seulement la fenetre SFML.

## Build

Le projet utilise CMake et telecharge SFML via `FetchContent`.

Commande habituelle :

```powershell
cmake --build out\build\x64-Debug --target logo
```

Dans l'environnement actuel, la construction MSVC peut echouer avant le code du
projet parce que le compilateur ne trouve pas des en-tetes standards C++ comme
`string`, `cmath`, `chrono` ou `optional`. Ce probleme semble venir de la
configuration de l'environnement MSVC, pas du code Logo.

Pour une verification syntaxique rapide, `g++` est disponible et peut etre
utilise sur les fichiers du coeur du projet.

## Points fragiles connus

- `FunctionCall` ne verifie pas encore proprement le cas d'une fonction
  inexistante avant de l'executer.
- Le moteur Logo depend directement du namespace global `turtle`, ce qui rend
  les tests sans SFML moins naturels.
- Les erreurs de parsing ne contiennent pas encore ligne/colonne, seulement le
  token fautif quand il existe.
- L'execution repose sur des iterateurs de `InstructionList`; une representation
  par index et pointeur de programme serait plus facile a deboguer.
- Le rendu SFML, l'etat de la tortue et l'export SVG sont encore regroupes dans
  `Turtle.cpp`.

## Refactoring conseille

Le meilleur premier refactoring serait de separer le moteur de dessin du rendu :

- une classe `TurtleState` ou `DrawingContext` qui contient position, direction,
  stylo et liste de traits ;
- un rendu SFML qui affiche cet etat ;
- un export SVG qui lit les memes traits.

Cela permettrait de tester le langage Logo sans ouvrir de fenetre graphique et
de rendre les exports plus simples a maintenir.