Programmation II (IFT1025), TP 1, Partie 2, 28 Janvier 2008 Date de remise : 19 Février 2008, à 23h59m59s Description de tâche: Les exercices a) et b) demandés en première partie seront revus et corrigés en période de TP, et les solutions pourront être utilisées comme base en seconde partie. Une version modifiée de REPL.java (utilisant Matcher au lieu de Reduce) sera aussi fournie. Les classes BinOp et UnOp ont étées modifiées afin de faciliter l'accès aux opérandes. Des getters ont étés ajoutés (getLeftOperand() et getRightOperand() pour BinOp et getOperand() pour UnOp). a) Étendre l'analyseur syntaxique de la première partie (qui sera donné dans la solution de la première partie) afin d'accepter des variables partout où les nombres sont permis. Cela donne la grammaire Expr' suivante: Expr ::= Operand | (UnaryOp Expr) | (Expr BinaryOp Expr) Operand ::= Number | Variable Number ::= [0-9]+ | [0-9]+.[0-9]+ Variable ::= [a-zA-Z]+ UnaryOp ::= + | - | & BinaryOp ::= + | - | * | / (Grammaire Expr') Les variables seront évidemment représentées avec la classe `Variable'. Et, comme en première partie, cela sera implanté dans la classe `Parser' par la méthode `public static Expr parse (ExprTokenizer stream)'. Il faudra également compléter la classe `Variable' (`Variable.java') afin qu'elle soit utilisable. La classe `ExprTokenizer' prend en compte les variables, vous pouvez utiliser `readToken()' pour récupérer les noms des variables. b) Développer un reconnaisseur d'expression arithmétique. S'inspirer des visiteurs déjà produits pour cela. Cette fonctionnalitée doit être implantée dans la classe `Matcher' (`Matcher.java'), qui sera utilisée comme visiteur d'Expr, qui retourne la partie de l'Expr qui a été trouvée ou null sinon. La classe `Matcher' prend une Expression contenant (ou non) des variables à sa construction, elle s'efforce ensuite de rechercher dans les expressions qu'elle visite une sous expression qui correspond à celle qu'elle a reçu à la construction. Exemple d'utilisation (tiré de REPL.java) : ======================================================================= // on crée le Parser, en lui passant l'expression recherchée System.out.print("Expression recherchee > "); Expr p = Parser.parseExpression(new ExprTokenizer()); match = new Matcher(p); // on parse l'expression qu'on veut visiter System.out.print("Expression visitee > "); Expr e = Parser.parseExpression(new ExprTokenizer()); // on recherche l'expression System.out.print("Expression Trouvee : "); e = (Expr)e.accept(match); // on affiche l'expression trouvée (s'il y en a une) if(e == null) System.out.print(e); else ((Writer)(e.accept(printer))).flush(); ======================================================================= Les règles de reconnaissance sont : Un opérateur ou un nombre sont reconnus pour eux-même. Une variable est reconnue pour une sous-expression quelconque. Exemples : $ java REPL Expression recherchee > 42 Expression visitee > 42 Expression recherchee : 42.0 Expression visitee : 42.0 Expression Trouvee : 42.0 Expression recherchee > a Expression visitee > 42 Expression recherchee : a Expression visitee : 42.0 Expression Trouvee : 42.0 Expression recherchee > 41 Expression visitee > 42 Expression recherchee : 41.0 Expression visitee : 42.0 Expression Trouvee : null Expression recherchee > (40 + a) Expression visitee > (40 + 2) Expression recherchee : (40.0 + a) Expression visitee : (40.0 + 2.0) Expression Trouvee : (40.0 + 2.0) Expression recherchee > a Expression visitee > (40 + 2) Expression recherchee : a Expression visitee : (40.0 + 2.0) Expression Trouvee : (40.0 + 2.0) Expression recherchee > (b + a) Expression visitee > (40 + (& 43)) Expression recherchee : (b + a) Expression visitee : (40.0 + (& 43.0)) Expression Trouvee : (40.0 + (& 43.0)) Expression recherchee > (b + (& f)) Expression visitee > (40 + (- 32)) Expression recherchee : (b + (& f)) Expression visitee : (40.0 + (- 32.0)) Expression Trouvee : null Expression recherchee > (& a) Expression visitee > (40 + (& 43)) Expression recherchee : (& a) Expression visitee : (40.0 + (& 43.0)) Expression Trouvee : (& 43.0) Expression recherchee > (+ (+ 5)) Expression visitee > (+ (+ (+ (- (- (+ 5)))))) Expression recherchee : (+ (+ 5.0)) Expression visitee : (+ (+ (+ (- (- (+ 5.O)))))) Expression Trouvee : null Expression recherchee > (+ (+ 5)) Expression visitee > (- (+ (+ (- (+ (+ 5)))))) Expression recherchee : (+ (+ 5.0)) Expression visitee : (- (+ (+ (- (+ (+ 5.O)))))) Expression Trouvee : (+ (+ 5.0)) Expression recherchee > (a + (- c)) Expression visitee > (& ((& 32) + (- 67))) Expression recherchee : (a + (- c)) Expression visitee : (& ((& 32.0) + (- 67.0))) Expression Trouvee : ((& 32.0) + (- 67.0)) Modalités de remise : Utiliser le système de remise. à partir d'une des machines du DIRO : $ ssh remise $ cd /dir/ou/est/votre/code $ remise ift1025 tp1-partie2 Parser.java Matcher.java Modalités d'évaluation Seconde partie 4/10 Analyseur syntaxique (bis) 1/10 Reconnaisseur 3/10 Le fonctionnement correct du code comptera pour la moitié des points, et la qualité du code (clarté, longueur, modularité, étendabilité, etc) pour l'autre moitié.