Description

Le pattern Interpreter fournit un cadre pour donner une représentation par objets de la grammaire d’un langage afin d’évaluer, en les interprétant, des expressions écrites dans ce langage.

Exemple

Nous voulons créer un petit moteur de recherche des véhicules basé sur la recherche par mot-clé dans la description des véhicules à l’aide d’expressions booléennes selon la grammaire très simple suivante :

expression ::= terme || mot-clé || (expression)

terme ::= facteur 'ou' facteur

facteur ::= expression 'et' expression

mot-clé ::= 'a'..'z','A'..'Z' {'a'..'z','A'..'Z'}*

Les symboles entre apostrophes sont des symboles terminaux. Les symboles non terminaux sont expression, terme, facteur et mot-clé. Le symbole de départ est expression.

Nous mettons en œuvre le pattern Interpreter afin de pouvoir exprimer toute expression répondant à cette grammaire selon un arbre syntaxique constitué d’objets afin de pouvoir l’évaluer en l’interprétant.

Un tel arbre n’est constitué que de symboles terminaux. Pour simplifier, nous considérons qu’un mot-clé constitue un symbole terminal en tant que chaîne de caractères.

L’expression (rouge ou gris) et récent et diesel va être traduite par l’arbre syntaxique de la figure 4-4.1.

Figure 4-4.1 - Arbre syntaxique correspondant à l’expression (rouge ou gris) et récent et diesel

L’évaluation...

Structure

1. Diagramme de classes

La figure 4-4.3 détaille la structure générique du pattern.

Ce diagramme de classes montre qu’il existe deux types de sous-expression, à savoir :

Les éléments terminaux qui peuvent être des noms de variable, des entiers, des nombres réels.
Les opérateurs qui peuvent être binaires comme dans l’exemple, unaires (opérateur « - ») ou prenant plus d’arguments comme des fonctions.

Figure 4-4.3 - Structure du pattern Interpreter

2. Participants

Les participants au pattern sont les suivants :

Expression est une classe abstraite représentant tout type d’expression, c’est-à-dire tout nœud de l’arbre syntaxique.
OpérateurAbstrait (OpérateurBinaire) est également une classe abstraite. Elle décrit tout nœud de type opérateur, c’est-à-dire possédant des opérandes qui sont des sous-arbres de l’arbre syntaxique.
OpérateurConcret1 et OpérateurConcret2 (OpérateurEt, OpérateurOu) sont des implantations d’OpérateurAbstrait décrivant totalement la sémantique de l’opérateur et donc capables de l’évaluer.
ÉlémentTerminal est une classe abstraite décrivant tout nœud correspondant à un élément terminal.
ÉlémentTerminalConcret1...

Domaines d’application

Le pattern est utilisé pour interpréter des expressions représentées sous la forme d’arbres syntaxiques. Il s’applique principalement dans les cas suivants :

La grammaire des expressions est simple.
L’évaluation n’a pas besoin d’être rapide.

Si la grammaire est complexe, il vaut mieux se tourner vers des analyseurs syntaxiques spécialisés. Si l’évaluation doit être effectuée rapidement, l’utilisation d’un compilateur peut s’avérer nécessaire.

Exemple en Java

Nous fournissons le code complet d’un exemple en Java qui non seulement permet l’évaluation d’un arbre syntaxique mais le construit également.

La construction de l’arbre syntaxique, appelée analyse syntaxique, est également répartie dans les classes, à savoir celles de la figure 4-4.2 sous la forme de méthodes de classe (méthodes préfixées du mot-clé static en Java).

Le code source de la classe Expression est donné à la suite. La partie relative à l’évaluation se limite à la déclaration de la signature de la méthode évalue.

Les méthodes prochainJeton, analyse et parse sont dédiées à l’analyse syntaxique. La méthode analyse est utilisée pour parser une expression entière alors que parse est dédiée à l’analyse soit d’un mot-clé soit d’une expression mise entre parenthèses.

public abstract class Expression 
{ 
  public abstract boolean evalue(String description); 
 
  // partie analyse syntaxique 
  protected static String source; 
  protected static int index; 
  protected static String jeton; 
 
  protected static void prochainJeton() 
  { 
    while ((index < source.length()) && (source.charAt 
      (index) == ' ')) 
      index++; 
    if (index == source.length()) 
      jeton = null; 
    else if ((source.charAt(index) == '(') ||  
      (source.charAt(index) == ')')) 
    { 
      jeton = source.substring(index, index + 1); 
      index++; 
    } 
    else 
    { 
      int debut = index; 
      while...

Le pattern Interpreter