Discussion :

[awabi]

Bonjour,

Je voulais de l'aide pour une question que je n'arrive pas à traiter.
Voici le libellé.

création d'un interpréteur pour un langage lambda

L'objectif est de créer un interpréteur pouvant s'appliquer à tout type de langage impératif de type C. Pour cela, nous allons considérer deux grands types de données : les instructions et les expressions.

Dans le cadre de ce projet, nous ne nous intéressons pas à la partie compilation (analyse des fichiers source) mais à la partie représentation interne d'un programme pour l'interpréteur. L'analyseur s'occupera de lire le code source puis, à l'aide de fabriques (voir la deuxième partie du sujet), générera une représentation interne du programme analysé. Cette représentation interne sera créée sous la forme d'un ensemble d'instances des classes définies pour le stockage interne du programme (voir la première partie du sujet).

Et je dois proposer une modélisation selon ou plusieurs hiérarchies de classes pour mettre en œuvre cet interpréteur.

Franchement je ne sais pas par où commencer!

Merci de votre aide.

[bruno_pages]

la question à résoudre est de chercher les classes permettant la représentation interne du programme sachant qu'il est de type impératif de type C

et que contient un tel programme ?

• des déclarations de variable globale (peut être hors sujet dans le cas présent)
• mais surtout des fonctions

et qu'est-ce qu'une fonction ?

• un nom
• un profile (type rendu, type et nom des paramètres)
• les instructions du corps

et qu'est-ce qu'une instruction ?

• une structure de contrôle (return, if, while ...) avec les instructions et expression associées
• une expression (y compris les affectations)

et qu'est-ce qu'une expression ?

• une constante
• une variable
• l'appel d'une opération (les arguments sont des expressions)
• l'appel d'un opérateur (les arguments sont des expressions), ce qui peut en interne ne pas être différentié de l'appel d'une opération, cette dernière étant juste builtin

etc ...

il faut donc faire les classes correspondantes, et en permettant bien-sûr l'exécution

par exemple (je n'ai as mis les constructeurs, type d'une valeur etc) un if c'est juste cela :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
class If implements Instruction {
  public void exec() {
    if (! test.eval().isZero())
      iftrue.exec();
    else
      iffalse.exec();
  }
  
  private Expression test;
  private Sequence iftrue;
  private Sequence iffalse;
}

avec

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
interface Instruction {
  public void exec();
}

abstract class Expression implements Instruction {
  public void exec() {
    eval();
  }
  
  public abstract Value eval();
}

interface Value {
  public boolean isZero();
}

class Sequence implements Instruction {
  public void exec() {
    int index;

    for (index = 0; index != instrs.length; index += 1)
      instrs[index].exec();
  }

  private Instruction[] instrs;
}

note : j'ai séparé Instruction et Expression, mais à la rigueur en permettant à une Value de représenter void la classe Instruction disparait

c'est donc assez facile et surtout amusant à faire

[awabi]

Merci.
Donc si je comprends bien je dois faire une classe boucle, conditionnelle, affectation, bloc d'instruction, entrée/sotie, les appels de fonctions ........ qui vont implémenter l'interface instruction.

[hed62]

Je te conseille de regarder le design pattern Interpreteur et Chaine de Responsabilité