Théorie des Langages

Théorie des Langages AntLR - Générateur d analyseurs Claude Moulin Université de Technologie de Compiègne Printemps 2015

Sommaire 1 Introduction 2

AntLR ANTLR : ANother Tool for Language Recognition URL : http://www.antlr.org. Auteur : Terence Parr (Université de San Francisco) Il fournit un parser qui interagit avec le lexer, fournit un rapport d erreur assez explicite et construit des arbres syntaxiques.

Objectif AntLR est un outil de génération automatique d analyseur permettant de reconnaître les phrases d un programme écrit dans un langage donné. L analyseur est généré à partir d un fichier grammaire contenant les règles définissant le langage. Code généré : classes en Java, C# ou C++,. Le fichier grammaire peut contenir également des actions : instructions insérées dans le code généré et qui doivent être compatibles avec le langage cible. AntLR définit un Méta Langage utilisé pour écrire le fichier grammaire.

Mise en œuvre d AntLR Sommaire 1 Introduction Mise en œuvre d AntLR Analyses Principe de fonctionnement Grammaire v4 2 Utilisation du paramètre de retour Utilisation d une Map Potentiel d ANTLR

Mise en œuvre d AntLR Génération du code (Windows) - On crée un fichier batch qui appelle le générateur d AntLR et permet de générer le code à partir d un fichier grammaire g4 (antlr-generat.bat). @echo off set CLASSPATH=lib/antlr-4.5-complete.jar; java org.antlr.v4.tool -visitor -o src/logoparsing grammars/logo.g4 pause Syntaxe : java org.antlr.v4.tool -visitor -o <output-folder> <grammaire.g4> ;

Mise en œuvre d AntLR Synchronisation avec Eclipse Synchroniser le code généré avec l environnement de développement Eclipse. Créer un projet Eclipse et un package pour les classes créées par le fichier batch ; Mettre le fichier batch à la racine du projet Créer la grammaire dans un répertoire (grammars/logo.g4) ; Utiliser l option -o pour indiquer le répertoire où les fichiers sont générés. Utiliser l option -visitor pour générer aussi les classes pour le design pattern Visitor.

Analyses Sommaire 1 Introduction Mise en œuvre d AntLR Analyses Principe de fonctionnement Grammaire v4 2 Utilisation du paramètre de retour Utilisation d une Map Potentiel d ANTLR

Analyses Analyses Analyse lexicale Flux de caractères Flux de tokens Analyse syntaxique Flux de tokens Interprétation Flux de tokens AST Traitement à partir de l arbre AST AST Interprétation

Analyses Analyse Lexicale L analyseur lexical (lexer) est l outil qui permet de découper un flux de caractères en un flux de mots du langage (tokens). Flux de caractères : a i r e := b a s e x h a u t e u r Lexer t 1 (aire) t 2 ( :=) t 3 (base) t 4 ( ) t 5 (hauteur)

Analyses Analyse Syntaxique L analyseur syntaxique (parser) vérifie que l ensemble des mots issus de l analyse lexicale (les tokens) forme une phrase syntaxiquement correcte. Il n y a pas de garantie concernant la sémantique de cette phrase. Flux de caractères : a i r e := b a s e x h a u t e u r Lexer t 1 (aire) t 2 ( :=) t 3 (base) t 4( ) t 5 (hauteur) Parser Arbre syntaxique

Analyses Génération

Analyses Exemple Grammaire permettant d écrire des expressions arithmétiques du type : 10-3 * 5 (20-10) / 4 Symboles opératoires : +, -, *, /, ^ ; Les opérandes sont des nombres entiers ; Il est possible d utiliser des parenthèses ; Les espaces et tabulations sont ignorés mais servent de séparateurs.

Analyses Fichier grammaire : Expr.g4 grammar Expr; @header { package expression; } INT : 0.. 9 + ; WS : [ \t\r\n]+ -> skip ; expr: sumexpr ; sumexpr : multexpr (( + - ) multexpr)* ; multexpr: powexpr (( * / ) powexpr)* ; powexpr : atom ( ^ atom)* atom: INT ( expr ) ;

Principe de fonctionnement Sommaire 1 Introduction Mise en œuvre d AntLR Analyses Principe de fonctionnement Grammaire v4 2 Utilisation du paramètre de retour Utilisation d une Map Potentiel d ANTLR

Principe de fonctionnement Règles Les catégories lexicale (lexer) sont en majuscule. Les catégories syntaxiques (variables) du parser sont en minuscule. expr est considéré comme l axiome de la grammaire. AntLr déclare automatiquement les tokens.

Principe de fonctionnement Classes générées (exemple Java) 1 Lexer : ExprLexer.java 2 Parser : ExprParser.java 3 Listes de tokens : Expr.tokens ; ExprLexer.tokens 4 Listeners : ExprListener.java (interface) ExprBaseListener.java (classe implémentant à vide l interface) 5 Visitors : ExprVisitor.java (interface) ExprBaseVisitor.java (classe implémentant à vide l interface)

Principe de fonctionnement Parser public class ExprParser extends Parser { public ExprParser(TokenStream input) {...} public final ExprContext expr() throws RecognitionException {...} public static class ExprContext extends ParserRuleContext {...} } Pour chaque règle syntaxique une méthode reprenant le nom de la règle et une classe contexte sont créées pour l analyse d une phrase.

Principe de fonctionnement Utilisation du parser Un parser ANTLR construit un arbre syntaxique à partir du programme donné en entrée. Il est nécessaire de parcourir cet arbre pour effectuer des actions. Traitements : Simple : un seul parcours de l arbre en profondeur d abord est nécessaire pour le traitement. On utilise un listener d événements. Evolué : le parcours de l arbre n est pas nécessairement complet ; une sous-arborescence peut être parcourue plusieurs fois. On utilise un visiteur d arbre.

Principe de fonctionnement Visitor ANTLR genère une interface visitor et une classe de base implémentant à vide l interface. Un visitor est un design pattern dont le but est d exécuter une opération sur les éléments d une structure (arbre) sans changer le type des éléments de la structure sur laquelle il opère. public class ExprBaseVisitor<T> extends ParseTreeVisitor<T> implements ExprVisitor<T> {... @Override public T visitexpr(exprparser.exprcontext ctx) { return visitchildren(ctx); }... }

Principe de fonctionnement Type du Visiteur ANTLR utilise un type paramètre pour la valeur de retour des méthodes du visiteur. Lors de la création de la classe visiteur il faut dériver la classe de base fournie par ANTLR avec le choix du type. Intéressant dans les cas simples lorsque toutes les méthodes doivent retourner le même type de valeurs. to implement. public class ExprEvalVisitor extends ExprBaseVisitor<Double> { @Override public Double visitexpr(exprcontext ctx) { return visit(ctx.sumexpr()); }... }

Principe de fonctionnement Méthode statique minimale public static String program = "programs/expr.txt"; public static void run_mini() { try { // lexer InputStream is = new FileInputStream(program); ANTLRInputStream stream = new ANTLRInputStream(is); Expr1Lexer lexer = new Expr1Lexer(stream); // parser CommonTokenStream tokens = new CommonTokenStream(lexer); ExprParser parser = new ExprParser(tokens); ParseTree tree = parser.expr(); System.out.println(tree.toStringTree(parser)); } catch(exception ex) { ex.printstacktrace(); } }

Principe de fonctionnement Résultat pour : 5*(10-2) (expr (sumexpr (multexpr (powexpr (atom 5)) * (powexpr (atom ( (expr (sumexpr (multexpr (powexpr (atom 10))) - (multexpr (powexpr (atom 2))))) ))))))

Grammaire v4 Sommaire 1 Introduction Mise en œuvre d AntLR Analyses Principe de fonctionnement Grammaire v4 2 Utilisation du paramètre de retour Utilisation d une Map Potentiel d ANTLR

Grammaire v4 Métalangage du lexer Opérateurs concaténation alternative : au moins 1 : + 0 ou plus (Kleene) : * 0 ou 1 :? négation : caractère quelconque :. Parenthèses pour forcer l appel des opérateurs.

Grammaire v4 Facilités Fragment pour simplifier l écriture de certaines règles : fragment LET : A.. Z a.. z ; fragment DIGIT : 0.. 9 ; ID : LET (LET DIGIT)+ ; SPACE : ; Pour ignorer les espaces, tabulations, retours à la ligne dans l écriture d un programme : WS : [ \t\r\n]+ -> skip ;

Grammaire v4 Nommer chaque alternative expr : sumexpr ; sumexpr : multexpr (( + - ) multexpr)* ; multexpr : powexpr (( * / ) powexpr)* ; powexpr : atom ( ^ atom)* ; atom : INT #int ( expr ) #parent ; Il est nécessaire de donner un nom à chaque cas d une alternative pour générer une méthode adaptée du visiteur

Grammaire v4 Accès aux nœuds de l arbre Un parser ANTLR construit un arbre syntaxique à partir du programme donné en entrée. Les méthodes des listener et visitor créés par ANTLR ont un paramètre (ctx) dont le type est une classe décrivant le nœud de l arbre créé par le parser. Ce paramètre permet d accéder aux nœuds fils. Depuis visitexpr on a accès à ctx.sumexpr(). Plusieurs fils de même nom sont accessibles dans une liste : depuis visitmultexpr on a accès à ctx.powexpr(). Accès aux tokens par leur nom : depuis visitint on a accès à INT().

Grammaire v4 Forme générale d une grammaire Déclaration de la grammaire grammar <GrammarName> ; Section @header{...} déclaration de package @header { package expression2; } Règles lexicales (Majuscule) Règles syntaxiques (Minuscule)

Sommaire 1 Introduction 2

Conditions Dans les langages de programmation, la grammaire doit permettre d écrire et d évaluer correctement des expressions aritmétiques : Respecter la priorité des opérateurs (grammaire). Assurer l associativité à gauche (grammaire). utiliser des parenthèses pour forcer certaines associations. Utiliser une grammaire compatible avec le type d analyse : ascendante (LR) ou descendante (LL). Evaluer durant ou après la construction de l arbre de dérivation (visiteur d arbre). 100-30 + 20 doit être évalué à 90 100-30 * 2 doit être évalué à 40 100-300 / 30 * 5 doit être évalué à 50

Principe 100-40 + 20 + 2 * 40

Arbre Priorité des opérateurs (* sur +) : le nœud de l opérateur de priorité plus importante se retrouve plus bas dans l arbre. Associativité à gauche pour des opérateurs de même priorité (+ et -) : le nœud de l opérateur plus à gauche est plus bas dans l arbre. L évaluation fait appel à l évaluation portant sur les nœuds fils (aspect récursif de la grammaire) sauf pour les feuilles qui doivent évaluer à partir de l écriture du lexème.

Grammaire LL Expr -> MultExpr Comp Comp -> + MultExpr Comp Comp -> - MultExpr Comp Comp -> MultExpr -> Atom Rest Rest -> * Atom Rest Rest -> / Atom Rest Rest -> Atom -> INT Atom -> ( Expr )

Grammaire Antlr expr : multexpr (( + - ) multexpr)* ; multexpr : atom (( * / ) atom)* ; atom : INT #int ( expr ) #parent ;

Arbres 100-40 + 20 + 2 * 40

Grammaire LR Expr -> Expr + MultExpr Expr -> Expr - MultExpr Expr -> MultExpr MultExpr : MultExpr * Atom MultExpr : MultExpr / Atom MultExpr : Atom Atom -> INT Atom -> ( Expr )

Rappels théoriques Une grammaire LL ne peut être récursive à gauche : La variable en partie gauche ne peut être en première position de la partie droite. Une grammaire LL doit être factorisée à gauche : deux règles de même partie gauche ne peuvent avoir une partie commençant par le même symbole. Une grammaire LR peut être récursive à gauche.

Principe du visitor Antlr Définir la méthode de visite de chaque nœud de l arbre (règle de la grammaire). Le paramètre contexte (ctx) de chaque méthode donne accès aux éléments fils du nœud courant. Elle peut appeler la méthode générale de visite des fils du nœud (visitchildren). Elle peut appeler la méthode de visite sur les nœuds fils pertinents : visit(ctx.bloc()). Question : comment stocker les valeurs évaluées (Double).

Antlr : Méthodes à implémenter visitexpr, visitmultexpr, visitint, visitparent Evaluation : Chaque méthode retourne la valeur calculée Chaque méthode stocke la valeur calculée dans une structure de données Chaque méthode doit synthétiser les valeurs calculées par les nœuds fils (la valeur est un attribut synthétisé).

Utilisation du paramètre de retour Sommaire 1 Introduction Mise en œuvre d AntLR Analyses Principe de fonctionnement Grammaire v4 2 Utilisation du paramètre de retour Utilisation d une Map Potentiel d ANTLR

Utilisation du paramètre de retour Antlr : Méthodes à implémenter visitexpr, visitmultexpr, visitint, visitparent Evaluation : Le visitor hérite de : ExprllBaseVisitor<Double>. Chaque méthode retourne la valeur calculée.

Utilisation du paramètre de retour Evaluation d un nombre Elle correspond à l alternative int. public Double visitint(intcontext ctx) { String inttext = ctx.int().gettext(); return Double.valueOf(intText); }

Utilisation du paramètre de retour Evaluation d une parenthèse Il suffit de visiter le nœud expression fils. public Double visitparent(parentcontext ctx) { return visit(ctx.expr()); }

Utilisation du paramètre de retour Une somme peut avoir plusieurs opérandes. On dispose de la liste des nœuds fils opérandes ctx.multexpr() et de tous les nœuds fils. Les opérateurs sont les fils de rang impair. public Double visitexpr(exprcontext ctx) int l = 0; int nb = ctx.multexpr().size(); Double result = visit(ctx.multexpr(l)); l++; int oprow = 1; while (l < nb) { Double right = visit(ctx.multexpr(l)); result = ctx.getchild(oprow).gettext().equals("+")? result + right : result - right; l++; oprow +=2 ; } return result; }

Utilisation du paramètre de retour produit Méthode similaire public Double visitmultexpr(multexprcontext ctx) { int l = 0; int nb = ctx.atom().size(); Double left = visit(ctx.atom(l)); Double result = left; l++; int oprow = 1; while (l < nb) { Double right = visit(ctx.atom(l)); result = ctx.getchild(oprow).gettext().equals("*")? result * right : result / right; l++; oprow +=2 ; } return result; }

Utilisation du paramètre de retour Programme public static void run_default_visitor() { try { InputStream is = new FileInputStream("programs/expll1.txt"); ANTLRInputStream stream = new ANTLRInputStream(is); ExprllLexer lexer = new ExprllLexer(stream); CommonTokenStream tokens = new CommonTokenStream(lexer); ExprllParser parser = new ExprllParser(tokens); ParseTree tree = parser.expr(); ExprllTreeVisitor visitor = new ExprllTreeVisitor(); Double result = visitor.visit(tree); System.out.println("Result = " + result); } catch(exception ex) { ex.printstacktrace(); } }

Utilisation du paramètre de retour Résultat Expression : 100-40 + 20 + 2 * 40 Résultat : 160 Avantage : le visiteur retourne le résultat. Désavantage : toutes les méthodes doivent retourner le même type de valeurs. La grammaire des expressions est intégrée dans une grammaire d instructions.

Utilisation d une Map Sommaire 1 Introduction Mise en œuvre d AntLR Analyses Principe de fonctionnement Grammaire v4 2 Utilisation du paramètre de retour Utilisation d une Map Potentiel d ANTLR

Utilisation d une Map Méthode Le visitor hérite de : ExprllBaseVisitor<Integer>. ANTLR fournit une classe ParseTreeProperty pour une map d objets indexés par les nœuds de l arbre. Chaque méthode stocke dans la map la valeur qu elle calcule avec comme clé son nœud contexte. Chaque méthode va chercher dans la map les valeurs dont elle a besoin (les clés sont certains nœuds fils). Chaque méthode retourne un entier qui indique si le calcul s est bien passé. On demande au visitor de donner le résultat.

Utilisation d une Map Déclaration de la Map // Map ParseTreeProperty<Double> attributes = new ParseTreeProperty<Double>(); // Accesseurs void setvalue(parsetree node, Double value) { attributes.put(node, value); } Double getvalue(parsetree node) { return attributes.get(node); } ParseTree tree; public Double getresult() { return getvalue(tree); }

Utilisation d une Map Evaluation d un nombre Elle correspond à l alternative int. atom : int parent INT #int / \ ( expr ) #parent INT ( expr ) ; public Integer visitint(intcontext ctx) { String inttext = ctx.int().gettext(); setvalue(ctx, Double.valueOf(intText)); return 0; }

Utilisation d une Map Evaluation d une parenthèse Il suffit de visiter le nœud expression fils. public Integer visitparent(parentcontext ctx) { visit(ctx.expr()); setvalue(ctx,getvalue(ctx.expr())); return 0; }

public Integer visitexpr(exprcontext ctx) { if (tree == null) tree = ctx; visitchildren(ctx); int l = 0; int nb = ctx.multexpr().size(); Double result = getvalue(ctx.multexpr(l)); l++; int oprow = 1; while (l < nb) { Double right = getvalue(ctx.multexpr(l)); result = ctx.getchild(oprow).gettext().equals("+")? result + right : result - right; l++; oprow +=2 ; } setvalue(ctx, result); return 0; } Utilisation d une Map : somme Liste des nœuds fils opérandes : ctx.multexpr().

Utilisation d une Map produit public Integer visitmultexpr(multexprcontext ctx) { visitchildren(ctx); int l = 0; int nb = ctx.atom().size(); Double result = getvalue(ctx.atom(l)); l++; int oprow = 1; while (l < nb) { Double right = getvalue(ctx.atom(l)); result = ctx.getchild(oprow).gettext().equals("*")? result * right : result / right; l++; oprow +=2 ; } setvalue(ctx, result); return 0; }

Utilisation d une Map Programme public static void run_default_map_visitor() { try { InputStream is = new FileInputStream("programs/expll1.txt"); ANTLRInputStream stream = new ANTLRInputStream(is); ExprllLexer lexer = new ExprllLexer(stream); CommonTokenStream tokens = new CommonTokenStream(lexer); ExprllParser parser = new ExprllParser(tokens); ParseTree tree = parser.expr(); ExprMapTreeVisitor visitor = new ExprMapTreeVisitor(); visitor.visit(tree); System.out.println("Result = " + visitor.getresult()); } catch (Exception ex) { ex.printstacktrace(); } }

Utilisation d une Map Résultat Expression : 5 * 3 / 2 * (15-2) Résultat : 97.5 Contrainte : chaque méthode doit stocker la valeur dans une structure ; le visitor doit mémoriser le nœud racine de l arbre. Avantage : les méthodes peuvent indiquer une information selon le type de retour choisi.

Potentiel d ANTLR Sommaire 1 Introduction Mise en œuvre d AntLR Analyses Principe de fonctionnement Grammaire v4 2 Utilisation du paramètre de retour Utilisation d une Map Potentiel d ANTLR

Potentiel d ANTLR Avancées de ANTLR v4 ANTLR v4 simplifie l écriture de règles de grammaire grâce à l algorithme ALL(*) Il élimine les conflits principaux des grammaires LL et donc des parser descendants : Non factorisation à gauche a : b INT b ( a ) Récursivité directe à gauche expr : expr * expr

Potentiel d ANTLR Arbre 100-40 + 20 + 2 * 40

Potentiel d ANTLR Grammaire v4 expr: expr ( * / ) expr #mult expr ( + - ) expr #sum atom #arule ; atom : INT #int ( expr ) #parent ;

Potentiel d ANTLR Interprétation expr: expr ( * / ) expr #mult expr ( + - ) expr #sum... ; La récursivité directe ne pose pas de problème. Le premier cas est considéré prioritaire ; il faut y mettre l opérateur considéré le plus important (*, /). L associativité est à gauche. 10-6 + 4 = 8 ; 100-10 * 4 = 60

Potentiel d ANTLR Evaluation d un nombre Elle correspond à l alternative int. public Integer visitint(intcontext ctx) { String inttext = ctx.int().gettext(); setvalue(ctx, Double.valueOf(intText)); return 0; }

Potentiel d ANTLR Evaluation d une parenthèse Elle correspond à l alternative parent. public Integer visitparent(parentcontext ctx) { visit(ctx.expr()); setvalue(ctx, getvalue(ctx.expr())); return 0; }

Potentiel d ANTLR Arule Elle correspond à l alternative arule. public Integer visitarule(arulecontext ctx) { visit(ctx.atom()); setvalue(ctx, getvalue(ctx.atom())); return 0; }

Potentiel d ANTLR somme 2 nœuds fils opérandes : ctx.expr(). public Integer visitsum(sumcontext ctx) { visitchildren(ctx); Double left = getvalue(ctx.expr(0)); Double right = getvalue(ctx.expr(1)); setvalue(ctx, ctx.getchild(1).gettext().equals("+")? left + right : left - right); return 0; }

Potentiel d ANTLR produit Méthode similaire. Le test sur l opéreur est différent.

Potentiel d ANTLR Retour du résultat On ajoute un niveau dans la grammaire. stat : expr ; public Integer visitstat(statcontext ctx) { tree = ctx; visitchildren(ctx); return 0; } public Double getresult() { return getvalue(tree.getchild(0)); }

Potentiel d ANTLR Programme public static void run_default_map_visitor() { try { InputStream is = new FileInputStream("programs/expll1.txt"); ANTLRInputStream stream = new ANTLRInputStream(is); ExprLexer lexer = new ExprLexer(stream); CommonTokenStream tokens = new CommonTokenStream(lexer); ExprParser parser = new ExprParser(tokens); ParseTree tree = parser.stat(); ExprMapTreeVisitor visitor = new ExprMapTreeVisitor(); visitor.visit(tree); System.out.println("Result = " + visitor.getresult()); } catch (Exception ex) { ex.printstacktrace(); } }

Potentiel d ANTLR INT et FLOAT INT : 0.. 9 + ; FLOAT : 0.. 9 +. ( 0.. 9 +)? ; atom : INT #int FLOAT #float ( expr ) #parent ;