Un parser génère un arbre, nommé parse tree. Cela reflète les règles de grammaire. Jison ne génère pas le parse tree par défaut et nous permet de créer cet parse tree dans n'importe quel format que nous voulons.

Un format possible est

Le format d'un nœud d'arbre de règles de grammaire

{
  rule: 'grammar rule name',
  items: []
}

Le format d'une feuille d'arbre de jeton

{
  token: 'TOKEN',
  value: value
}

D'abord nous écrivons deux fonctions: une pour construire un noeud de parse tree et une autre pour construire une feuille de parse tree.

function rule (rule_name, items)
{
  return {
    rule: rule_name,
    items: items
  };
}

function token (token_name, value)
{
  return {
    token: token_name,
    value: value
  };
}

Nous allons écrire les deux fonctions dans la section %{ %} du fichier alf.y.

La règle de début renvoie le parse tree.

alf.l

Ws                      \s+
Identifier              [A-Za-z\$_][A-Za-z\$_0-9]*
 
%% 
"var" 		        { return 'VAR'; }
","		        { return ','; }
{Ws}                    { /* skip whitespace */ }
{Identifier}		{ return 'IDENTIFIER'; }

alf.y

%{
// function for grammar rule
function rule (rule_name, items)
{
  return {
    rule: rule_name,
    items: items
  };
}
 
// function for token
function token (token_name, value)
{
  return {
    token: token_name,
    value: value
  };
}
%}
 
%% 
 
start: variable 
		{
			return $1;
		};
 
 
variable:	VAR variables
			{
				$$ = rule ('variable', [token ('VAR', $1), $2]);
			};
 
variables:	IDENTIFIER ',' variables   
			{
				$$ = rule ('variables', 
				           [
				              token ('IDENTIFIER', $1), 
				              token (',', ','), 
				              $3
				           ]
				          );
			}
	        | IDENTIFIER 
			{
				$$ = token ('IDENTIFIER', $1);
			};

Pour vérifier la corectitude de la grammaire des, exercises accédez à Jison Debugger. Dans l'exemple présenté, on réalise la génération d'un arbre d'analyse (parse tree) pour la déclaration des variables, en utilisant les fonctions rule et token.

1. Clonez/téléchargez la structure du TP. Ajoutez à la grammaire décrite dans l'exemple les règles nécessaires pour l'utilisation des expressions (plusieurs expressions) du laboratoire précédent. Un programme peut contenir aussi des déclarations des variables, que l'emploi des expressions, donc la nouvelle grammaire doit accepter plusieurs instructions (statements). Le delimitateur des instructions est ';'. (3p)
2. Ajouter des règles pour l'attribution d'une valeur à une variable. La règle pour cela est

   variable = value

   . La valeur est un nombre (entier ou réel). Pour pouvoir utiliser une variable dans une expression, il faut vérifier avant qu'elle a été déjà définie.

    a = 4; 2 + 3 * a;(**2p**)
     - Ajouter des règles pour que les variables puissent prendre des valeurs qui sont des expressions. (**1p**)
     - Ajouter des règles à la grammaire pour qu'elle accèpte les appels de fonctions. Un appel de fonction ressemble à <code>function_name (parameter1, parameter2, parameter3, ...)

   . (4p)

Solutions