Reader in2 = new InputStreamReader (System.in) ;

import java.io.*; // La classe Reader est dans le package java.io

class Cat {

  public static void main(String [] args) {
    Reader entree =  new InputStreamReader(System.in) ;

    try {
      for (;;) {// Boucle infinie, on sort par break
        int c = entree.read (); // Lire un caractère
        if (c == -1)            // Fin de l'entrée
          break;
        else                    // Cas normal
          System.out.print ((char)c);
      }
      entree.close();
    } catch (IOException e) { // En cas de malaise
      System.err.print("Malaise : ") ;  
      System.err.println(e.getMessage()) ;
      System.exit(-1) ; // Terminer le programme sur erreur
    }      
  }
}

class Lexer {
  Lexer (Reader in)  // Constructeur qui prend un Reader en entrée
  Lexeme getToken () // Renvoie le prochain lexème, ou null à la fin
  void close ()      // Ferme l'entrée du lexer
}

• Comprendre tout ce qui concerne l'entrée. Une seule solution, inspirez vous de l'exemple ci-dessus et lancez vous.
• Organiser correctement les lectures de caractères dans la classe Lexer, selon le célèbre principe ``plus un pas en arrière'' et celui plus souterrain de ``je peux parfois reculer d'un pas, mais d'un seul''. Il est conseillé d'écrire une boucle de lecture qui délègue les tâches auxiliaires à de nombreuse méthodes privées, genre :

  /* Deux méthodes pour une lecture avec mémoire d'un caractère */
   private int get_char()       // lit le caractère suivant en attente.
   private void put_back(int c) // le prochain ``get_char'' renvoie ``c''.
  
   // Diverses méthode utiles
   private static boolean digit(int c) // Pas besoin d'expliquer
   private int skip_spaces ()          // renvoie le premier non-espace à lire
    ...
  

• Transformer une suite de caractères lus de gauche à droite en un entier. Miracle : pas besoin de récursion, il y a quelques trucs classiques.

maranget@manche ~/TD/TD-4 >  java TestLexer 
123
Lexème : 123
1 2 3
Lexème : 1
Lexème : 2
Lexème : 3
1+2+3
Lexème : 1
Lexème : +
Lexème : 2
Lexème : +
Lexème : 3
^d

class Stack {
  ... // Champs de l'objet pile (cf. plus loin)

  Stack () { // Constructeur des piles
    /* Initialisation des champs */
  }

  int pop () { }

  void push (int i) { }

  public String toString () { // Renvoie une chaîne qui représente la pile
   
  }
}

maranget@manche ~/TD/TD-4 > java HP < petit.hp 
 321 : 321
 123 : 123, 321
   - : 198
 111 : 111, 198
   + : 309

• L'instruction POP, dépile un élément.

       : 1, 2, ...
   POP : 2, ...
  

• L'instruction SWAP échange les deux éléments du sommet de pile.

        : 1, 2, ...
   SWAP : 2, 1, ...
  

• L'instruction DUP empile le sommet de pile.

       : 1, ...
   DUP : 1, 1, ...
  

• L'instruction ROTU effectue une rotation vers le haut, tous les éléments de la pile montent d'un cran, sauf le sommet qui se retrouve en fond de pile.

        : 1, 2, 3, 4, 5
   ROTU : 2, 3, 4, 5, 1
  

• L'instruction ROTD effectue la rotation de pile en sens inverse.

        : 1, 2, 3, 4, 5
   ROTD : 5, 1, 2, 3, 4
  

1. Créer un nouveau lexème, on se rendra vite compte que le plus simple est de d'abord considérer une nouvelle sorte de lexèmes, genre les identificateurs (suite de lettres en majuscule), puis de vérifier les instructions possibles, une par une, idéalement dans la classe Lexeme, à l'aide d'une méthode statique :

   static Lexeme instruction (String s)
   

2. Réaliser la fonctionnalité de la nouvelle instruction, en modifiant la classe HP et éventuellement la classe Stack.

• L'étiquette LBLn, où n est un chiffre de zéro à neuf définit un point de branchement.
• L'instruction GTOn transfère l'exécution vers l'étiquette correspondante.
• L'instruction GSBn fait de même. En outre, l'exécution RTN retransfèrera le contrôle juste après le dernier GSBn effectué si il existe. Sinon, l'exécution s'arrête. Ces deux instructions servent à écrire des sous-routines.
  
  
• Les tests sont franchement bizarres. L'instruction XLTY compare la valeur au sommet de la pile x, avec la valeur juste dessous le sommet de pile y. Ensuite, si x < y le contrôle passe à l'instruction suivante. Dans le cas contraire, le contrôle saute l'instruction suivante. Cela permet de brancher à l'étiquette 1 si x < y par deux instructions : ``XLTY GTO1''.
• L'instruction XNEZ se comporte de même, en testant cette fois x différent de zéro. (On peut évidemment réaliser des tas de comparaisons selon ce principe XEQY, etc.)

%% Fonction fib recursive
LBL1
2 SWAP
XLTY GTO2
DUP ROTU SWAP - %Optim d'enfer ``2'' est de'ja sur la pile
GSB1
ROTD 1 -
GSB1
+
RTN
%%% Cas terminal
LBL2 POP POP 1 RTN

1. Lire complètement le programme et le charger en mémoire en résolvant les références (ici, une étiquette correspond à une position d'instruction).
2. Exécuter le programme en mémoire.

maranget@manche ~/TD/TD-4 > java HP 1 3 GSB0 RTN < pgm.hp
======= Programme chargé =========
000    1
001    3
002 GSB0
003  RTN
004 SWAP
005    -
006  RTN
======= Table des étiquettes =======
LBL0 = 004
LBL1 = 000
LBL2 = 000
LBL3 = 000
LBL4 = 000
LBL5 = 000
LBL6 = 000
LBL7 = 000
LBL8 = 000
LBL9 = 000

======= Exécution ========
000    1 : 1
001    3 : 3, 1
002 GSB0 : 3, 1
004   SWAP : 1, 3
005      - : 2
006    RTN : 2
003  RTN : 2

Ce document a été traduit de L^AT_EX par H^EV^EA.