summaryrefslogtreecommitdiffstats
path: root/tp2.tex
blob: 6c820eb925a3fff2467675e20027d348d4fafa3e (plain)
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
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
%% 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{http://javacc.java.net/doc/docindex.html} 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\mathtt{0}\rdquote\endash\ldquote\mathtt{9}\rdquote]{+} \;
(\ldquote\mathtt{.}\rdquote \;
[\ldquote\mathtt{0}\rdquote\endash\ldquote\mathtt{9}\rdquote]*)?\\
\end{aligned}
\]
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 $23$).  Pour cela, on peut par exemple introduire un nouveau
nonterminal $\mathit{terme}$ 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{terme} \;
( \ldquote\hbox{\texttt{+}}\rdquote \mathit{terme}
\,|\, \ldquote\hbox{\texttt{-}}\rdquote \mathit{terme}){*}\\
\mathit{terme} & \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{terme}$, 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=terme()
    (
      "+" b=terme() { a += b; }
    | "-" b=terme() { a -= b; }
    )* { return a; }
}

double terme():
{ 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
revoyer $2$.  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 $18$, et \texttt{-1-2} doit
renvoyer $-3$.  Vérifier que le moins unaire marche aussi devant les
parenthèses (\texttt{-(2+3)} doit renvoyer $-5$).  On pourra aussi
ajouter le $+$ unaire (qui ne change pas le nombre).  Pour cela, on
pourra introduire un nouveau nonterminal $\mathit{unaire}$
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{terme} & \rightarrow \mathit{unaire} \;
(\ldquote\hbox{\texttt{*}}\rdquote \mathit{unaire}
\,|\, \ldquote\hbox{\texttt{/}}\rdquote \mathit{unaire}
){*}\\
\mathit{unaire} & \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 terme():
{ double a,b; }
{
    a=unaire()
    (
      "*" b=unaire() { a *= b; }
    | "/" b=unaire() { a /= b; }
    )* { return a; }
}

double unaire():
{ 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{unaire}$ 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$.

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 512$ ;
$\hbox{\texttt{-1\char"5E\relax 2}} \rightsquigarrow -1$ ;
$\hbox{\texttt{(-1)\char"5E\relax 2}} \rightsquigarrow 1$ ;
$\hbox{\texttt{2\char"5E\relax -1}} \rightsquigarrow 0.5$ ;
$\hbox{\texttt{2*3\char"5E\relax 2*3}} \rightsquigarrow 54$.

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

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

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

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



%
%
%
\end{document}