1. Le langage reconnu est int {op int}^*, on peut donc sans trop réfléchir produire cette méthode ok.

   void ok() {   if (tok.nature != Token.int) error("entier", tok) ;   step() ;   while (tok != Token.EOF) {     switch (tok.nature) {       case Token.ADD: case Token.SUB: case Token.MUL: case Token.DIV:         step() ;         break ;       default:         error("opérateur", tok) ;     }     if (tok.nature != Token.int) error("entier", tok) ;     step() ;   } }

2. La boucle while s'exprime aisément par une récursion terminale :

   void ok() {   expression() ;   if (tok.nature != Token.EOF) error("EOF", tok) ; } void expression() {   if (tok.nature != Token.INT) error("entier", tok) ;   step() ;   switch (tok.nature) {     case Token.ADD: case Token.SUB: case Token.MUL: case Token.DIV:       step() ;       return expression() ;     default:       return ;   } }

   On peut alors associer la production S → E eof à la méthode ok et les productions E → int op E ∣ int à la méthode expression. On a fait le choix de retourner immédiatement de la méthode expression quand le deuxième lexème du flux n'est pas un opérateur. Cela s'explique en disant que dans ce cas, c'est nécessairement la production E → int qui s'applique éventuellement, l'autre ne pouvant s'appliquer. En fait, il ne faut effectivement retourner que si le lexème en question est Token.EOF. Dans les autres cas, il faudrait signaler une erreur. Mais comme ce lexème sera finalement vérifié (par la méthode ok), on peut s'abstenir.
   
   Bref, on a essentiellement suivi la grammaire de Samir. La règle est grossièrement, une méthode par non-terminal, dont le corps est écrit par transformation des membres droits associés, en remplaçant les non-terminaux par des appels de méthode, et les terminaux par des vérification de lexèmes, ou des choix (ici il y un seul choix entre un opérateur et « autre chose »).