%% This is a LaTeX document.  Hey, Emacs, -*- latex -*- , get it?
\documentclass[12pt,a4paper]{article}
\usepackage[a4paper,margin=2cm]{geometry}
\usepackage[francais]{babel}
\usepackage[utf8]{inputenc}
\usepackage[T1]{fontenc}
%\usepackage{ucs}
\usepackage{times}
% A tribute to the worthy AMS:
\usepackage{amsmath}
\usepackage{amsfonts}
\usepackage{amssymb}
\usepackage{amsthm}
%
\usepackage{mathrsfs}
\usepackage{wasysym}
\usepackage{url}
%
\usepackage{graphics}
\usepackage[usenames,dvipsnames]{xcolor}
%\usepackage{tikz}
%\usetikzlibrary{arrows,automata,positioning}
\usepackage[hyperindex=false]{hyperref}
%
\theoremstyle{definition}
\newtheorem{comcnt}{Tout}
\newcommand\thingy{%
\refstepcounter{comcnt}\smallbreak\noindent\textbf{\thecomcnt.} }
\newcommand\exercice{%
\refstepcounter{comcnt}\bigbreak\noindent\textbf{Exercice~\thecomcnt.}}
\renewcommand{\qedsymbol}{\smiley}
%
\newcommand{\liff}{\mathrel{\Longleftrightarrow}\relax}
%
\DeclareUnicodeCharacter{00A0}{~}
\DeclareUnicodeCharacter{03B5}{$\varepsilon$}
%
\DeclareMathSymbol{\tiret}{\mathord}{operators}{"7C}
\DeclareMathSymbol{\traitdunion}{\mathord}{operators}{"2D}
\DeclareSymbolFont{roman}{OT1}{cmr}{m}{n}
\DeclareMathSymbol{\ldquote}{\mathopen}{roman}{"5C}
\DeclareMathSymbol{\rdquote}{\mathopen}{roman}{"22}
\DeclareMathSymbol{\endash}{\mathbin}{roman}{"7B}
%
%
\DeclareFontFamily{U}{manual}{} 
\DeclareFontShape{U}{manual}{m}{n}{ <->  manfnt }{}
\newcommand{\manfntsymbol}[1]{%
    {\fontencoding{U}\fontfamily{manual}\selectfont\symbol{#1}}}
\newcommand{\dbend}{\manfntsymbol{127}}% Z-shaped
\newcommand{\danger}{\noindent\hangindent\parindent\hangafter=-2%
  \hbox to0pt{\hskip-\hangindent\dbend\hfill}}
%
\newcommand{\spaceout}{\hskip1emplus2emminus.5em}
\newif\ifcorrige
\corrigetrue
\newenvironment{corrige}%
{\ifcorrige\relax\else\setbox0=\vbox\bgroup\fi%
\smallbreak\noindent{\underbar{\textit{Corrigé.}}\quad}}
{{\hbox{}\nobreak\hfill\checkmark}%
\ifcorrige\relax\else\egroup\fi\par}
%
%
%
\begin{document}
\ifcorrige
\title{TP \texttt{JavaCC} — Corrigé}
\else
\title{TP \texttt{JavaCC}}
\fi
\author{David A. Madore}
\maketitle

\centerline{\textbf{INF105}}

{\footnotesize
\immediate\write18{sh ./vc > vcline.tex}
\begin{center}
Git: \input{vcline.tex}
\end{center}
\immediate\write18{echo ' (stale)' >> vcline.tex}
\par}

\pretolerance=8000
\tolerance=50000


%
%
%


JavaCC est un programme permettant de créer automatiquement un
analyseur syntaxique (=parseur, \textit{parser} en anglais) pour un
langage décrit sous forme de grammaire hors contexte.  Le principe est
le suivant : on écrit un fichier \texttt{.jj} qui contient un mélange
de description du langage (sous forme de productions dans une syntaxe
évoquant les expressions régulières) et de code Java à exécuter
lorsque ces différentes productions sont rencontrées.  Le programme
\texttt{javacc} convertit ce fichier \texttt{.jj} en un fichier
\texttt{.java} qui contient le code de l'analyseur ; on peut ensuite
compiler ce fichier avec \texttt{javac} comme n'importe quel code
Java (puis l'exécuter avec \texttt{java}).

La documentation de JavaCC est accessible en ligne sur
\url{https://javacc.org/doc} mais il est
probablement plus simple d'apprendre par imitation à partir du fichier
proposé.

Sur \url{http://perso.enst.fr/~madore/inf105/Calculatrice.jj} (à
télécharger, ou à recopier directement depuis
\texttt{\char`\~madore/Calculatrice.jj} dans les salles de TP) on
trouvera le code d'une calculatrice très simple écrit en JavaCC.  On
peut compiler et lancer ce code (après l'avoir recopié chez soi) en
lançant successivement :

\noindent
\indent\texttt{\char`\~madore/bin/javacc Calculatrice.jj}\\
\indent\texttt{javac Calculatrice.java}\\
\indent\texttt{java Calculatrice}

On peut alors taper des expressions arithmétiques telles que
\texttt{3+4} ou \texttt{2*6} (terminer chaque calcul en tapant
Enter, et terminer le programme en tapant Control-D).  Vérifier que
cela fonctionne correctement.

\bigbreak

Initialement, la grammaire de la calculatrice définie dans
\texttt{Calculatrice.jj} est donnée par :
\[
\begin{aligned}
\mathit{expression} & \rightarrow \mathit{element} \;
( \ldquote\hbox{\texttt{+}}\rdquote \mathit{element}
\,|\, \ldquote\hbox{\texttt{-}}\rdquote \mathit{element}
\,|\, \ldquote\hbox{\texttt{*}}\rdquote \mathit{element}
\,|\, \ldquote\hbox{\texttt{/}}\rdquote \mathit{element}
){*}\\
\mathit{element} & \rightarrow \mathit{Number}\\
\mathit{Number} & \rightarrow
[\ldquote\texttt{0}\rdquote\endash\ldquote\texttt{9}\rdquote]{+} \;
(\ldquote\texttt{.}\rdquote \;
[\ldquote\texttt{0}\rdquote\endash\ldquote\texttt{9}\rdquote]*)?\\
\end{aligned}
\]
Il s'agit d'une grammaire « étendue » au sens où le membre de droite
des règles de production autorise l'utilisation de métacaractères
« ${|}$ » (disjonction), « ${*}$ » (étoile de Kleene), « ${+}$ » et
« ${?}$ » de manière semblable aux expressions rationnelles :
c'est-à-dire que JavaCC note $X|Y$ pour un choix entre $X$ et $Y$,
ainsi que $X{*}$ pour un nombre quelconque de répétitions de $X$ et
$X{+}$ pour la variante imposant au moins une répétition et $X{?}$
pour un $X$ factultatif (les parenthèses permettent par ailleurs de
grouper).  En principe, on pourrait éliminer l'utilisation de ces
métacaractères en s'inspirant de la manière dont on démontre que tout
langage rationnel est algébrique (par exemple $X\rightarrow Y{*}$ peut
être remplacé par $X\rightarrow \varepsilon\,|\,YX$), mais l'analyseur
LL de JavaCC ne sera pas forcément capable de gérer la grammaire ainsi
transformée, donc il est préférable d'utiliser les métacaractères
lorsque c'est possible.

Le code important se situe dans \texttt{Calculatrice.jj} au niveau de
la ligne \texttt{double expression():} ; le bloc qui suit définit la
production $\mathit{expression}$ ainsi que le code à exécuter quand
elle est rencontrée.

\bigbreak

(1) Que se passe-t-il quand on demande de calculer \texttt{3+4*5} à
la calculatrice ?  Pourquoi ?

Modifier la grammaire pour avoir une priorité correcte des opérations
(\texttt{*} et \texttt{/} doivent être prioritaires sur \texttt{+} et
\texttt{-}, et en particulier \texttt{3+4*5} doit
renvoyer \texttt{23.0}).  Pour cela, on peut par exemple introduire un
nouveau nonterminal $\mathit{term}$ représentant un terme d'une somme
ou différence, et qui est lui-même formé de produits ou quotients.
Tester la calculatrice ainsi modifiée.

\begin{corrige}
La calculatrice renvoie \texttt{35.0} quand on lui demande de calculer
\texttt{3+4*5}, c'est-à-dire qu'elle analyse ce mot comme
\texttt{(3+4)*5}.  La raison en est que la production
$\mathit{expression}$ produit un arbre d'analyse « plat », et le code
est alors exécuté séquentiellement (on part de \texttt{a=3}, on
exécute ensuite \texttt{a+=4} et enfin \texttt{a*=5}).

Pour corriger ce problème, on va modifier la grammaire de la manière
suivante :
\[
\begin{aligned}
\mathit{expression} & \rightarrow \mathit{term} \;
( \ldquote\hbox{\texttt{+}}\rdquote \mathit{term}
\,|\, \ldquote\hbox{\texttt{-}}\rdquote \mathit{term}){*}\\
\mathit{term} & \rightarrow \mathit{element} \;
(\ldquote\hbox{\texttt{*}}\rdquote \mathit{element}
\,|\, \ldquote\hbox{\texttt{/}}\rdquote \mathit{element}
){*}\\
\end{aligned}
\]
(le reste est inchangé) : ceci forcera l'arbre d'analyse de
\texttt{3+4*5} à comporter deux $\mathit{term}$, en l'occurrence
\texttt{3} et \texttt{4*5}, qui s'évalueront dans les bonnes valeurs.

Voici à quoi peut ressembler le code JavaCC modifié pour refléter la
grammaire en question :
\begin{verbatim}
double expression():
{ double a,b; }
{
    a=term()
    (
      "+" b=term() { a += b; }
    | "-" b=term() { a -= b; }
    )* { return a; }
}

double term():
{ double a,b; }
{
    a=element()
    (
      "*" b=element() { a *= b; }
    | "/" b=element() { a /= b; }
    )* { return a; }
}
\end{verbatim}
On vérifie bien que la nouvelle calculatrice renvoie \texttt{23.0}
quand on lui demande de calculer \texttt{3+4*5}.
\end{corrige}

\medbreak

(2) La calculatrice ne gère pas les parenthèses : ajouter cette
fonctionnalité et tester.  Par exemple, \texttt{(3+5)/(2*2)} doit
renvoyer \texttt{2.0}.  Pour cela, on pourra ajouter une nouvelle production
pour $\mathit{element}$ correspondant à une $\mathit{expression}$
entourée de parenthèses.

\begin{corrige}
On va maintenant modifier la production pour $\mathit{element}$ et en
ajouter une nouvelle, à savoir :
\[
\mathit{element} \rightarrow \mathit{Number}
\,|\, \ldquote\hbox{\texttt{(}}\rdquote \mathit{expression} \ldquote\hbox{\texttt{)}}\rdquote
\]

Le code JavaCC pour cette production peut ressembler à ceci :
\begin{verbatim}
double element():
{ Token t; double a; }
{
    t=<NUMBER> { return Double.parseDouble(t.toString()); }
|   "(" a=expression() ")" { return a; }
}
\end{verbatim}
(ici, \texttt{Token} est un type interne à JavaCC utilisé pour les
productions du lexer ; on ne touche pas à la première partie, on se
contente d'ajouter une deuxième production).
\end{corrige}

\medbreak

(3) La calculatrice ne gère pas le $-$ unaire (pour indiquer l'opposé
d'un nombre) : ajouter cette fonctionnalité et tester.  Par exemple,
\texttt{-3*-6} doit renvoyer \texttt{18.0}, et \texttt{-1-2} doit
renvoyer \texttt{-3.0}.  On veut que le moins unaire marche aussi
devant les parenthèses : par exemple, \texttt{-(2+3)} doit
renvoyer \texttt{-5.0}.  On pourra aussi ajouter le $+$ unaire (qui ne
change pas le nombre).  Pour cela, on pourra introduire un nouveau
nonterminal $\mathit{factor}$ représentant un élément éventuellement
précédé d'un $-$ (ou d'un $+$) unaire.

\begin{corrige}
On modifie la grammaire comme suit :
\[
\begin{aligned}
\mathit{term} & \rightarrow \mathit{factor} \;
(\ldquote\hbox{\texttt{*}}\rdquote \mathit{factor}
\,|\, \ldquote\hbox{\texttt{/}}\rdquote \mathit{factor}
){*}\\
\mathit{factor} & \rightarrow \mathit{element} \;
\,|\, \ldquote\hbox{\texttt{+}}\rdquote \mathit{element}
\,|\, \ldquote\hbox{\texttt{-}}\rdquote \mathit{element}\\
\end{aligned}
\]
et le code JavaCC correspondant pourrait être :
\begin{verbatim}
double term():
{ double a,b; }
{
    a=factor()
    (
      "*" b=factor() { a *= b; }
    | "/" b=factor() { a /= b; }
    )* { return a; }
}

double factor():
{ double a; }
{
    a=element() { return a; }
|   "+" a=element() { return a; }
|   "-" a=element() { return -a; }
}
\end{verbatim}

(Plusieurs variations sont possibles : par exemple, si on fait suivre
le \texttt{-} unaire d'un $\mathit{factor}$ au lieu d'un
$\mathit{element}$, cela permet d'autoriser \texttt{-{}-3} comme façon
d'écrire \texttt{+3}.)
\end{corrige}

\medbreak

(4) La calculatrice ne gère pas l'opération puissance : introduire
celle-ci sous la notation du caractère ``\texttt{\char"5E}''
(accent circonflexe) : attention, on veut que l'opération
\texttt{\char"5E} soit prioritaire sur toutes les autres (addition,
soustraction, multiplication, division, et opérations unaires), et on
veut qu'elle soit associative \emph{à droite}, c'est-à-dire par
exemple que \texttt{2\char"5E\relax 3\char"5E\relax 2} doit calculer $2^{3^2}
= 2^9 = 512$.

On pourra pour cela introduire un nouveau nonterminal $\mathit{power}$
représentant un $\mathit{element}$ suivi facultativement d'un
\texttt{\char"5E} et d'un nouveau $\mathit{power}$.

La méthode Java permettant de calculer $a^b$ s'écrit \texttt{Math.pow(a,b)}.

Tester notamment les calculs suivants : $\hbox{\texttt{2\char"5E\relax
    3\char"5E\relax 2}} \rightsquigarrow \texttt{512.0}$ ;
$\hbox{\texttt{-1\char"5E\relax 2}} \rightsquigarrow \texttt{-1.0}$ ;
$\hbox{\texttt{(-1)\char"5E\relax 2}} \rightsquigarrow \texttt{1.0}$ ;
$\hbox{\texttt{(2+3)\char"5E\relax 2}} \rightsquigarrow \texttt{25.0}$ ;
$\hbox{\texttt{2\char"5E\relax -1}} \rightsquigarrow \texttt{0.5}$ ;
$\hbox{\texttt{2*3\char"5E\relax 2*3}} \rightsquigarrow \texttt{54.0}$.

\begin{corrige}
Pour obtenir l'associativité \emph{à droite}, on va définir un
nonterminal $\mathit{power}$ pour lequel on va définir une
production faisant qu'une $\mathit{power}$ peut s'analyser comme
un $\mathit{element}$ suivi d'un ``$\texttt{\char"5E}$'' suivi
facultativement d'une nouvelle $\mathit{power}$, c'est-à-dire
qu'on modifie la grammaire ainsi :
\[
\begin{aligned}
\mathit{factor} & \rightarrow \mathit{power} \;
\,|\, \ldquote\hbox{\texttt{+}}\rdquote \mathit{power}
\,|\, \ldquote\hbox{\texttt{-}}\rdquote \mathit{power}\\
\mathit{power} & \rightarrow \mathit{element}
( \ldquote\hbox{\texttt{\char"5E}}\rdquote \mathit{factor}
){?}\\
\end{aligned}
\]
avec le code JavaCC suivant :
\begin{verbatim}
double factor():
{ double a; }
{
    a=power() { return a; }
|   "+" a=power() { return a; }
|   "-" a=power() { return -a; }
}

double power():
{ double a,b; }
{
    a=element()
    (
      "^" b=factor() { a = Math.pow(a,b); }
    )? { return a; }
}
\end{verbatim}

Remarquez l'utilisation du métacaractère « $?$ » pour marquer le
caractère facultatif de la partie
$\ldquote\hbox{\texttt{\char"5E}}\rdquote \mathit{factor}$ ; on aurait
pu tenter d'écrire la règle sous la forme $\mathit{power} \rightarrow
\mathit{element} \;|\; \mathit{element}
\ldquote\hbox{\texttt{\char"5E}}\rdquote \mathit{factor}$ pour un code
JavaCC qui ressemblerait à « \texttt{\{ a=element() \{ return a; \}
    |\penalty-100\hskip.5emplus1em a=element() "\char"5E" b=factor()
    \{ return Math.pow(a,b); \} \}} », mais ce code fait échouer
JavaCC car au moment où il reconnaît le nonterminal
$\mathit{element}$, l'analyseur ne peut pas encore savoir dans quelle
branche de l'alternative il sera.

\smallbreak

Voici la grammaire finale :
\[
\begin{aligned}
\mathit{expression} & \rightarrow \mathit{term} \;
( \ldquote\hbox{\texttt{+}}\rdquote \mathit{term}
\,|\, \ldquote\hbox{\texttt{-}}\rdquote \mathit{term}){*}\\
\mathit{term} & \rightarrow \mathit{factor} \;
(\ldquote\hbox{\texttt{*}}\rdquote \mathit{factor}
\,|\, \ldquote\hbox{\texttt{/}}\rdquote \mathit{factor}
){*}\\
\mathit{factor} & \rightarrow \mathit{power} \;
\,|\, \ldquote\hbox{\texttt{+}}\rdquote \mathit{power}
\,|\, \ldquote\hbox{\texttt{-}}\rdquote \mathit{power}\\
\mathit{power} & \rightarrow \mathit{element}
( \ldquote\hbox{\texttt{\char"5E}}\rdquote \mathit{factor}
){?}\\
\mathit{element} &\rightarrow \mathit{Number}
\,|\, \ldquote\hbox{\texttt{(}}\rdquote \mathit{expression} \ldquote\hbox{\texttt{)}}\rdquote\\
\mathit{Number} & \rightarrow
[\ldquote\texttt{0}\rdquote\endash\ldquote\texttt{9}\rdquote]{+} \;
(\ldquote\texttt{.}\rdquote \;
[\ldquote\texttt{0}\rdquote\endash\ldquote\texttt{9}\rdquote]*)?\\
\end{aligned}
\]

Le code JavaCC correspondant peut se trouver à l'adresse
\url{http://perso.enst.fr/~madore/inf105/Calculatrice-final.jj}
\end{corrige}



%
%
%
\end{document}