Télécharger pour lire hors ligne
![Tree-‐Walker
(LogoTree.g)
Pour
les
instructions
élémentaires
suivantes
(CF
fenêtre
de
gauche),
l'arbre
suivant
(fenêtre
de
droite)
est
généré
par
le
parser:
La
représentation
AntLR
sous
forme
de
liste
est
la
suivante:
(PROGRAMME
(FPOS
[500
500])
(AV
100)
(TD
300)
)
AntLR
utilise
deux
tokens
imaginaires:
UP
et
DOWN
pour
indiquer
les
niveaux
dans
l'arbre.
Expressions
arithmétiques
Nous
avons
implémenté
certaines
opérations
arithmétiques
telles
que
l'addition,
la
soustraction,
la
multiplication,
la
division
et
l'opération
puissance.
Afin
de
créer
une
grammaire
non
ambigüe,
nous
avons
donné
la
priorité
aux
opérateurs
multiplier
et
diviser
sur
les
opérateurs
additionner
et
soustraire.
Lexer
(Logo.g)
8](https://image.slidesharecdn.com/logo-130220010109-phpapp02/85/Logo-8-320.jpg){kind=logo}
Logo
- 1. NF11 -‐ Génération d'analyseur lexical et syntaxique Fayçal Laatef & Friscira Elsa Groupe p014 Objectifs • Créer une grammaire du langage Logo et une représentation intermédiaire d’un programme Logo. • Générer un analyseur syntaxique de cette grammaire. • Créer un interpréteur graphique du langage Logo. • Crée une table des symboles d’un programme. • Vérifier quelques conditions sémantiques. 1
- 2. Table des matières OBJECTIFS ............................................................................................................................................................ 1 I. INTRODUCTION, QU'EST CE QUE LOGO? ............................................................................................. 3 II. STRUCTURE DE NOTRE PROJET ........................................................................................................... 3 III. LEXER, PARSER ET INTERPRETEUR DU LANGAGE LOGO ........................................................... 4 A. INTRODUCTION ................................................................................................................................................ 4 C. ANALYSE SYNTAXIQUE: LE PARSER (LOGO.G) ................................................................................................ 5 D. ANALYSE SEMANTIQUE: TREE WALKER (LOGOTREE.G) ............................................................................... 6 E. EN RESUME, COMMENT AJOUTER UNE FONCTIONNALITE? ............................................................................. 7 E. QUELLES FONCTIONNALITES AVONS-‐NOUS AJOUTEES? .................................................................................. 7 PRINCIPALES COMMANDES DE LA TORTUE .......................................................................................................................... 7 EXPRESSIONS ARITHMETIQUES ............................................................................................................................................. 8 EXPRESSIONS BOOLEENNES ................................................................................................................................................... 9 IDENTIFICATEURS, AFFECTATION ......................................................................................................................................... 9 IV. STRUCTURES DE CONTROLE ............................................................................................................. 12 EVALUATION DIFFEREE D'UNE ARBORESCENCE .............................................................................................................. 12 LA REPETITION ...................................................................................................................................................................... 13 L'ALTERNATIVE (SI) ............................................................................................................................................................. 14 V. PROCEDURES ET FONCTIONS ............................................................................................................. 15 PROCEDURES .......................................................................................................................................................................... 15 REMARQUES: ..................................................................................................................................................... 17 VI. ELEMENTS NON TRAITES ET DIFFICULTES RENCONTREES .................................................... 18 .......................................................................................................................................... 18 VII. CONCLUSION 2
- 3. I. Introduction, qu'est ce que Logo? Le langage Logo est un langage de programmation qui recouvre deux concepts: • un mode d’apprentissage inspiré des travaux de Jean Piaget sur le développement cognitif de l’enfant • un type d’environnement informatique, à partir d'un langage adapté du LISP Le langage Logo est connu pour sa simplicité mais est également capable de manipuler des expressions arithmétiques, des expressions booléennes ou de mettre en place des structures de contrôles telles que les conditions, les boucles, les procédures et les fonctions. Le but de ce projet est de créer un analyseur lexical et syntaxique du langage Logo. Pour cela, nous avons utilisé AntLR (Another Tool for Language Recognition). 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é. II. Structure de notre projet 3
- 4. L'interface graphique, réalisée par Claude Moulin, nous permet d'observer et de valider le travail de développement des grammaires que nous réalisons. L'objectif du projet est de réaliser une grammaire du langage LOGO afin de pouvoir l'analyser. Il y a donc trois types d'analyses à réaliser: 1. l'analyse lexicale 2. l'analyse syntaxique 3. l'analyse sémantique (traitement à partir de l'arbre AST) Remarque: AntLR utilise une analyse descendante de type LL. III. Lexer, Parser et interpréteur du langage Logo a. Introduction Pour réaliser les analyses lexicales et syntaxiques du langage LOGO, nous avons spécifié une grammaire (Lexer,Parser) qui décrit la façon de découper un flux de caractères en un flux de mots du langage (tokens) puis d'analyser le flux sortant. Avec AntLR, nous avons créé un fichier "nomFichier.g" définissant les unités lexicales et syntaxiques de la grammaire. AntLR a ensuite créer lui même un fichier annexe contenant la grammaire du lexer. Enfin, il a généré les classes correpondant au lexer et au parser. 4
- 5. b. Analyse lexicale: le lexer (Logo.g) L'analyseur lexical (ou lexer) est l'outil qui permet de découper un flux de caractères en un flux de mots du langage: les tokens. Flux de caractères => Flux de tokens Ajout des tokens au lexer dans la grammaire Logo.g: c. Analyse syntaxique: le parser (Logo.g) L'analyseur syntaxique (ou parser) vérifie que l'ensemble des mots issus de l'analyse lexicale (tokens) forme une phrase syntaxiquement correcte. Le parser va donc générer un arbre syntaxique abstrait (AST) à partir des tokens générés par le lexer. Flux de tokens => AST Nous avons utilisée la règle suivante du parser comme axiome de notre grammaire: Remarque importante: Ici, nous avons utilisé un token imaginaire: PROGRAMME. Cela nous permet de résoudre les problèmes de récursivité à gauche. En effet, AntLR réalise une analyse descendante de type LL et nous avons vu en cours, qu'une grammaire récursive à gauche ne pouvait pas être LL(1). 5
- 6. AntLR donne la possibilité de créer automatiquement, semi automatiquement ou manuellement l'arbre AST. Dans le fichier Logo.g, nous avons ajouté une section option indiquant au parser de créer l'arbre AST: Les méthodes du parser associées aux règles de la grammaire ne sont alors plus de type void mais d'un type structuré dont le nom reprend celui de la méthode. Que fait AntLR? Pour chaque règle: AntLR crée une racine d'arborescence Pour chaque token présent dans une règle: • AntLR crée un noeud (Tree) • Ajoute ce noeud comme fils du noeud courant (les noeuds forment donc une liste) • Attache les noeuds de la liste à un noeud racine de type nil. Ajout des instructions au parser dans la grammaire Logo.g: Les noeuds AV, TD et TG dans l'exemple ci-‐dessus sont des noeuds racine car ils sont suffixés avec un symbole ^. Au contraire, pour ne pas créer de noeud avec un token, on peut le suffixer avec un symbole !. d. Analyse sémantique: tree Walker (LogoTree.g) Le tree-‐walker parcourt l'arbre AST généré par le parser et exécute les actions. Pour les fonctionnalités concernant l'UI (qui consistent à tracer un trait sur l'écran en se déplaçant par exemple), nous avons fait appel à la classe Traceur. Pour les autres fonctionnalités comme par exemple l'affectation de variables, nous avons fait appel à des fonctions que nous avons développées dans la classe LogoUtil.java. 6
- 7. e. En résumé, comment ajouter une fonctionnalité? Pour ajouter une fonctionnalité, il faut: Dans la grammaire Logo.g: 1. Ajouter un token au lexer 2. Ajouter une instruction au parser 3. Sauvegarder (les classes lexer et parser sont générées) Dans la grammaire LogoTree.g: 1. Ajouter le parsing d'un arbre 2. Faire générer le parseur d'arbre 3. Ajouter une méthode à la classe logogui.Traceur e. Quelles fonctionnalités avons-‐nous ajoutées? Principales commandes de la tortue Nous avons implémenté les commandes de base permettant à la tortue d'avancer, d'effectuer une rotation, de reculer ... Lexer (Logo.g) Parser (Logo.g) 7
- 8. Tree-‐Walker (LogoTree.g) Pour les instructions élémentaires suivantes (CF fenêtre de gauche), l'arbre suivant (fenêtre de droite) est généré par le parser: La représentation AntLR sous forme de liste est la suivante: (PROGRAMME (FPOS [500 500]) (AV 100) (TD 300) ) AntLR utilise deux tokens imaginaires: UP et DOWN pour indiquer les niveaux dans l'arbre. Expressions arithmétiques Nous avons implémenté certaines opérations arithmétiques telles que l'addition, la soustraction, la multiplication, la division et l'opération puissance. Afin de créer une grammaire non ambigüe, nous avons donné la priorité aux opérateurs multiplier et diviser sur les opérateurs additionner et soustraire. Lexer (Logo.g) 8
- 9. Parser (Logo.g) Tree-‐Walker (LogoTree.g) Expressions booléennes De la même façon que pour les expressions arithmétiques, nous avons implémenté les expressions booléennes de base telles que égal, différent, supérieur et inférieur. Parser (Logo.g) Tree-‐Walker (LogoTree.g) Identificateurs, affectation Variables globales La déclaration et l’affectation d’une variable globale sont effectuées grâce au mot-‐clé DONNE. Dans le tree-‐walker, nous appelons la méthode setVar(String,Double) définie dans la classe LogoUtil du fichier LogoUtil.java. 9
- 10. Tree-‐Walker (LogoTree.g) LogoUtil.java La fonction setVar de la classe LogoUtil stocke les variables dans une table de hachage "variables" qui associe le nom de la variable (String) à sa valeur (Double). Variables locales Pour les variables locales, nous avons du gérer le problème des portées imbriquées. Nous avons représenté chaque portée par une hashmap contenant le dictionnaire des symboles qui sont déclarés dans la portée concernée. Pour gérer le problème des portées imbriquées, nous avons donc utilisé une pile de hashmap. • A chaque fois que nous rentrons dans un bloc, nous empilons la hashmap contenant les variables locales déclarées dans ce bloc • A chaque fois que nous sortons d'un bloc, nous dépilons cette hashmap (qui se trouve au sommet de la pile) Ainsi, avec cette méthode, la portée courante courante est toujours la portée au sommet de la pile. Contexte d'un symbole = portée dans laquelle il est (+ portées dans laquelle la portée est imbriquée) éventuellement 10
- 11. LogoUtil.java Insertion d'un identificateur dans un contexte L’insertion d’un identificateur se fait dans le dictionnaire de la portée en sommet de pile. Recherche d'un identificateur dans un contexte Pour rechercher un identificateur nous utilisons son contexte (qui possède une pile de portées donc une pile de hashmaps). Nous cherchons donc l'identificateur dans cette pile de portées de la façon suivante: 1. nous regardons si l'identificateur se situe dans la portée courante (donc au sommet de la pile de portées du contexte) 2. si nous ne trouvons pas l'identificateur dans la portée courante, nous parcourons la pile élément par élément jusqu'à trouver l'identificateur. (parcours de la portée la plus récente à la portée la plus ancienne) 3. si nous ne trouvons pas l'identificateur dans la pile de portée (donc s'il n'est dans aucune portée) alors nous regardons dans la hashmap contenant les variables globales. 4. si l'identificateur n'est pas dans cette hashmap, il n'est pas défini. 11
- 12. LogoUtil.java IV. Structures de contrôle Evaluation différée d'une arborescence Pour les structures de contrôle qui suivent, nous avons utilisé le parsing différé. En quoi cela consiste-‐t-‐il? Le parsing différé se fait à l'aide d'une règle que l'on écrit dans la grammaire. On mémorise l'index sur lequel cette règle doit commencer le matching. Avant d'appeler la méthode du parser associée à la règle, on empile l'index sur lequel elle doit commencer le matching et on dépile ensuite le noeud qu'elle aura placé pour la suite du matching et qui s'avère inutile. 12
- 13. La répétition Repeat Tree-‐Walker (LogoTree.g) Nous avons placé un point (.) après l'expression "exp" afin que le parsing ne se fasse pas par défaut. Le point représente l'index de l'arborescence. L'arbre AntLR associé est donc le suivant: REPEAT DOWN <atom> <.> UP. Rappel: AntLR utilise deux tokens imaginaires: UP et DOWN pour indiquer les niveaux dans l'arbre. La règle list_evaluation doit connaître l'index de l'arborescence car lorsqu'elle va être appelée, elle va devoir dépiler cet index. Le code situé dans la boucle FOR ci-‐dessus effectue les actions suivantes: • empile l'index du noeud racine traité par list_evaluation push(mark_list) • appelle la méthode list_evaluation list_evaluation() = règle qui permet de parser un arbre dont la racine est le token LIST et dont les fils sont les instructions 13
- 14. • dépile le noeud superflu que list_evaluation va empiler pop() Les méthode push() et pop() sont des méthodes que nous avons développées dans LogoTree.g afin d'alléger l'écriture: While Pour le while, nous avons suivi la même méthode que pour le repeat. Tree-‐Walker (LogoTree.g) L'alternative (si) Dans le cas de l'alternative, nous utilisons la possibilité d'ignorer une branche de l'arbre au cours du parcours initial et d'y revenir par la suite en sauvegardant son index. La particularité de l'instruction alternative est que le second bloc d'instructions est facultatif. Si l'expression booléenne renvoie vraie alors exécuter le bloc 1 sinon exécuter le bloc 2 (optionnel car "?"): 14
- 15. Nous initialisons le marqueur d'index (mark_list2) à 0. La récupération de l'index a lieu grâce à la méthode "input.mark()"que l'on affecte à mark_list2. Si mark_list2>0 alors nous pouvons traiter le second bloc d'instructions, sinon, l'interpréteur ne l'a pas trouvé. Tree-‐Walker (LogoTree.g) V. Procédures et fonctions Procédures Afin de générer des branches d'instructions qui seront plus facilement accessibles lors du parcours de l'arbre AST, nous avons créé deux tokens imaginaires: ARG et et PARAM. ARG est utilisé lors de la déclaration de notre procédure. PARAM est utilisé lors de l'appel de notre procédure. Nous avons également créé une classe Procedure qui contient les deux structures suivantes: • une liste ordreParam utilisée pour enregistrer les paramètres et leur ordre au moment de la déclaration de notre procédure 15
- 16. private ArrayList<String> ordreParam; • une hashmap params utilisée pour associer une valeur à chaque variable lors de l'appel de notre procédure private ArrayList<String> ordreParam; Déclaration d'une procédure La fonction "pushProcedure" définie dans la classe LogoUtils, va nous permettre d'empiler notre procédure sur une pile de procédures afin de simplifier l'ajout des paramètres lors de la déclaration. 16
- 17. Appel d'une procédure On va récupérer le nom de la procédure en cours et on va dire à notre variable de type LogoUtil (u) de récupérer la procédure du nom contenu dans la variable: "nameProc" c'est à dire de la chercher dans la pile puis de l'extraire de cette pile. On va ensuite modifier cette procédure en associant une valeur à chaque variable déclarée lors de la déclaration de procédure. Remarque: Arité d'une procédure La méthode getArite() dans notre classe Procedure vérifie que le nombre de paramètres passés lors de l'appel de cette procédure ( dans la hashmap params) est bien égal au nombre de paramètres déterminé lors de la déclaration de cette procédure (dans la liste ordreParam). 17
- 18. VI. Eléments non traités et difficultés rencontrées Eléments non traités Faute de temps, nous n'avons pas implémenté les fonctionnalités suivantes: • Les procédures récursives • La primitive LOOP qui renvoie le nombre de tours dans une boucle. • La primitive STOP. • La possibilité d'utiliser les opérateurs AND et OR dans les expressions booléennes. Difficultés rencontrées • Au début du projet, il nous a fallu du temps pour nos familiariser la syntaxe et le fonctionnement de AntLR. • Nous avons rencontré quelques difficultés dans la gestion des tokens imaginaires générés par AntLR <UP> and <DOWN>. Cela nous créait des erreurs de marquage. Il y avait un décalage entre l'arbre que l'on créait et l'arbre que l'on parsait. VII. Conclusion Ce projet nous a permis d'aller plus loin dans notre compréhension des différents types d'analyse: lexicale, syntaxique et sémantique. Il nous a permis également de voir un exemple concret et d'appliquer les principes théoriques vus en cours. Nous avons désormais une vision globale plus claire sur les différentes phases allant de l'écriture à l'exécution d'un programme. 18