Skip to content

Latest commit

 

History

History
115 lines (76 loc) · 5.47 KB

TP5.md

File metadata and controls

115 lines (76 loc) · 5.47 KB

Année: 2024-2025

Travaux pratiques 5

Objectifs

  1. Gérer les variables dans l'interpréteur : Permettre l'affectation, le stockage et la récupération de valeurs pour des variables dans l'interpréteur.

  2. Implémenter, parser et évaluer des expressions lambda : Ajouter le support des fonctions anonymes et évaluer dynamiquement les expressions mathématiques contenant des variables.

Exercice 5.1 [★★]

Gérer les variables dans l'interpréteur

Objectif :

Étendre l'interpréteur existant pour qu'il prenne en charge l'affectation simple de variables. L'objectif est de permettre l'affectation de valeurs à des variables, tout en respectant certaines contraintes de type et en utilisant l'encodage UTF-8 pour les noms de variables.

Contraintes :

  1. Pas de changement de type : Une fois qu'une variable est affectée à un type (entier, nombre réel ou chaîne de caractères), elle doit conserver ce type. Par exemple, si x = 12, on ne peut pas réaffecter x = 12.3.
  2. Types autorisés : Seuls trois types sont autorisés pour les variables :
    • Entiers (par exemple, 12)
    • Nombres réels (par exemple, 12.3)
    • Chaînes de caractères (par exemple, "hello")
  3. Noms de variables en UTF-8 : Les noms de variables peuvent contenir des caractères Unicode et doivent être encodés en UTF-8.

Structures de données :

  • Table de symboles (variables) : Utiliser une table (ou une structure équivalente) pour stocker les noms des variables, leurs valeurs et leur type.

Étapes à suivre :

  1. Ajouter la gestion des variables dans l'interpréteur :

    • Implémenter une table de symboles qui stocke les variables avec leurs valeurs et types respectifs.

  2. Reconnaître les affectations de variables :

    • Lorsqu'une commande de type > variable = valeur est saisie, ajouter ou mettre à jour la variable dans la table de symboles, en respectant les contraintes de type.

  3. Accéder aux valeurs des variables :

    • Si l'utilisateur saisit uniquement le nom d'une variable (par exemple, > x), afficher la valeur actuelle de cette variable.
    • Si la variable n'est pas définie, afficher un message d'erreur indiquant que la variable n'existe pas.

Exemple :

  • Entrée : > x = 4

  • Sortie : Variable x définie avec la valeur 4 (entier)

  • Entrée : > z = "Bonjour"

  • Sortie : Variable z définie avec la valeur "Bonjour" (chaîne de caractères)

  • Entrée : > x = 12.3

  • Sortie : Erreur : changement de type non autorisé pour la variable x

  • Entrée : > π = 3.14

  • Sortie : Variable π définie avec la valeur 3.14 (nombre réel)

  • Entrée : > y

  • Sortie : Erreur : la variable y n'est pas définie

Exercice 5.2 [★★★]

Implémenter, parser et évaluer des expressions lambda

Objectif :

Étendre l'interpréteur pour qu'il prenne en charge les expressions lambda de la forme (lambda x.une expression mathématique sans/avec parenthèses qui contient x) un nombre/variable. L'objectif est de permettre l'évaluation des expressions lambda où la variable x est remplacée par une valeur numérique ou une variable déjà définie.

Contraintes :

  1. Les expressions lambda doivent suivre la syntaxe : (lambda x.une expression mathématique) où une expression mathématique peut inclure des opérateurs arithmétiques de base (+, -,...) et des parenthèses.
  2. Lors de l'évaluation, la valeur numérique ou la variable fournie après l'expression lambda doit remplacer toutes les occurrences de x dans l'expression mathématique.
  3. Si une variable est utilisée comme argument après l'expression lambda, elle doit être définie dans l'interpréteur, sinon une erreur doit être renvoyée.

Étapes à suivre :

  1. Parsing de l'expression lambda :

    • Identifier la structure (lambda x.une expression mathématique) et extraire la variable x ainsi que l'expression mathématique.
    • Vérifier que l'expression mathématique est bien formée et respecter les règles de priorité des opérateurs.

  2. Évaluation de l'expression lambda :

    • Remplacer la variable x par la valeur fournie (soit un nombre, soit la valeur de la variable déjà définie).
    • Évaluer l'expression mathématique résultante après substitution.

  3. Gestion des erreurs :

    • Si une variable non définie est utilisée comme argument, afficher un message d'erreur approprié.
    • Assurer une gestion correcte des types de valeurs (entiers, réels, chaînes de caractères).

Exemple :

  1. Entrée : > (lambda x.x + 2 * x) 3

    • Étapes :
      • Le parseur identifie lambda x et l'expression x + 2 * x.
      • Remplace x par 3.
      • Évalue l'expression 3 + 2 * 3 = 9.
    • Sortie : 9

  2. Entrée : > (lambda x.(x + 2) * x) y

    • Supposons que la variable y ait été définie précédemment avec la valeur 4.
    • Étapes :
      • Le parseur identifie lambda x et l'expression (x + 2) * x.
      • Remplace x par 4.
      • Évalue l'expression (4 + 2) * 4 = 24.
    • Sortie : 24

  3. Entrée : > (lambda x.x + 1) z

    • Si la variable z n'est pas définie dans la table de symboles.
    • Sortie : Erreur : la variable z n'est pas définie

Structures de données :

  • Table de symboles (variables) : Pour récupérer les valeurs des variables déjà définies.
  • Parseur d'expressions lambda : Pour analyser et extraire les composants de l'expression lambda.