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 les exercises accessez Jison Debugger.

1. Clonez/telechargez la structure pour le TP.Ajoutez les règles de grammaire pour les expressions (plusieurs expressions) du laboratoire précédent à la grammaire décrite dans l'exemple. Un programme possède des déclarations et expressions variables. Le delimitateur des instructions est ';'. (3p)
2. Ajouter une attribution de valeur variable. La règle pour cela est

   variable = value

   . La valeur est un nombre. Pour utiliser une variable dans une expression, elle doit être déjà définie. (2p)

3. Ajouter des règles pour que les variables puissent prendre des valeurs qui sont des expressions. (1p)
4. Ajouter des appels de fonction à la grammaire. Un appel de fonction ressemble à

   function_name (parameter1, parameter2, parameter3, ...)

   . (4p)

Solutions