Differences
This shows you the differences between two versions of the page.
|
alf:laboratoare:03 [2020/03/02 23:34] ioana_maria.culic [Exercises] |
alf:laboratoare:03 [2022/03/20 21:22] (current) diana.ghindaoanu [Exercices] |
||
|---|---|---|---|
| Line 1: | Line 1: | ||
| - | ====== TP 3 - Strings et Regex ====== | + | ====== TP 3 - Introduction à ANTLR4. Lexer ====== |
| - | ===== Strings ===== | + | Ce TP est destiné à vous présenter le fonctionnement d'un **lexer**, son but étant de diviser un texte dans des parties identifiables, appelées jetons (**tokens**), comme dans l'exemple suivant. |
| - | Nous avons une variable str qui est une chaîne | + | |
| - | Les fonctions disponibles sont: | + | {{ :alf:laboratoare:lexer.png?600&nolink }} |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/length|str.length]]// - en réalité il est une variable qui nous donne la longueur de la chaîne | + | En informatique, on va réaliser cette division à l'aide de l'outil ANTLR, spécialement créé pour traiter les textes structurés. |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/substring|str.substring (start, end)]]// - retourne la sous-string à partir de la position //start// | + | |
| - | * //start// - position de debut de sous-string | + | |
| - | * //end// - position de fin de sous-string (optionnel) | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/split|str.split (separator, limit)]]// - divise le string dans un array avec des éléments séparés //separator// | + | |
| - | * //separator// - un string avec les caractères séparent les éléments du string original | + | |
| - | * //limit// - le nombre maximum de divisions (optionnel) | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toUpperCase|str.toUpperCase ()]]// - retour un nouveau string avec toutes les lettres majuscules | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/toLowerCase|str.toLowerCase ()]]// - retour un nouveau string avec toutes les lettres minuscules | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/indexOf|str.indexOf (search, index)]]// - | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/lastIndexOf|str.lastIndexOf (search, index)]]// - | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/Trim|str.trim ()]]// - | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith|str.startsWith (search, position)]]// - | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith|str.endsWith (search, positon)]]// - | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/replace|str.replace (subStr, newSubStr)]]// - | + | |
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/charAt|str.charAt (index)]]// - | + | |
| - | * //str[positon]// - | + | |
| - | Pour en savoir plus, lisez la [[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String|documentation String complète]]. | + | ===== ANTLR4 ===== |
| + | ANTLR (ANother Tool for Language Recognition) est un générateur d'analyseurs pour lire, traiter, exécuter ou traduire du texte structuré ou des fichiers binaires. Il est largement utilisé pour créer des langages, des outils et des frameworks. À partir d'une description de langage formel, ANTLR génère un analyseur pour ce langage qui peut automatiquement créer des arbres d'analyse, dont on va discuter dans les cours et les TPs suivants. ANTLR génère également automatiquement des arborescences qu'on peut utiliser pour visiter les nœuds de ces arbres afin d'exécuter du code spécifique à l'application. | ||
| - | ===== Expressions régulières ===== | ||
| - | ==== Mathematique ==== | + | ==== Configuration ==== |
| + | L'outil nécessaire pour générer du code TypeScript à partir d'ANTLR4 est écrit en Java. Pour utiliser pleinement la cible ANTLR4 TypeScript (y compris la possibilité de régénérer le code à partir d'un fichier après les modifications), un environnement d'exécution Java (JRE) doit être installé sur la machine du développeur. Le code généré lui-même utilise plusieurs fonctionnalités nouvelles de TypeScript 2.0. | ||
| + | |||
| + | === Installation globale === | ||
| + | |||
| + | - Installer une version de [[https://www.java.com/en/|Java]] 1.6+ (on recommande 1.8+). Vous pouvez vérifier l'installation à l'aide de la commande suivante: {{ :alf:laboratoare:java-version.PNG?400&nolink }} | ||
| + | - Télécharger le runtime complet d'antlr4 pour Java, ainsi que l'archive pour JavaScript depuis ce [[https://www.antlr.org/download/|lien]]. Le fichier ''.jar'' et le dossier decompressé pour JavaScript doivent etre sauvegardés dans un dossier spécial que vous devrez créer sur votre ordinateur, **C:\Javalib**. {{ :alf:laboratoare:runtime.JPG?550&nolink }} | ||
| + | - Ajouter ''antlr-4.9-complete.jar'' à la variable d'environnement CLASSPATH (aussi pour les variables de systeme que pour celles de votre utilisateur). Vous pouvez lire plus sur les variables d'environnement [[https://support.shotgunsoftware.com/hc/en-us/articles/114094235653-Setting-global-environment-variables-on-Windows|ici]]. {{ :alf:laboratoare:set-system-var.PNG?450&nolink }} | ||
| + | - Créer 2 fichiers [[https://www.computerhope.com/jargon/b/batchfil.htm|batch]]. | ||
| + | - Le fichier ''antlr4.bat'' permet d'utiliser antlr4 dans la ligne de commande depuis n'importe quel fichier. Il doit contenir la commande **java org.antlr.v4.Tool %**. | ||
| + | - Le fichier ''grun.bat'' est utilisé pour tester le fichier d'entrée et pour afficher l'arbre d'analyse sous des formes différentes. Il doit contenir la commande **java org.antlr.v4.runtime.misc.TestRig %***. {{ :alf:laboratoare:batch-files.PNG?550&nolink }} | ||
| + | - Ajouter le dossier **C:\Javalib** a la variable d'environnement PATH. {{ :alf:laboratoare:set-javalib-path.PNG?500&nolink }} | ||
| + | - Vérifier l'installation en tapant ''antlr4'' dans le Command Prompt. {{ :alf:laboratoare:check-antlr4.PNG?400&nolink }} | ||
| + | |||
| + | <note important> | ||
| + | Pour plus d'informations, vous pouvez consulter ce [[https://github.com/antlr/antlr4/blob/master/doc/getting-started.md|tutoriel]]. | ||
| + | </note> | ||
| + | |||
| + | === Installation pour TypeScript === | ||
| + | - Créer un nouveau projet en Visual Studio Code et initialisez le fichier **package.json** avec la commande ''npm init''. | ||
| + | - Installer ''antlr4ts'' en tant que dépendance d'exécution (runtime dependency) depuis le Terminal de VSCode. <code bash>npm install antlr4ts --save</code> | ||
| + | - Installer ''antlr4ts-cli'' en tant que dépendance de développement depuis le Terminal de VSCode.<code bash>npm install antlr4ts-cli --save-dev</code> | ||
| + | - Installer [[https://marketplace.visualstudio.com/items?itemName=mike-lischke.vscode-antlr4|l'extension d'ANTLR4]] depuis le navigateur web ou directement du MarketPlace de Visual Studio Code. {{ :alf:laboratoare:antlr4-extension.JPG?550&nolink }} | ||
| + | - Redemarrer Visual Studio Code | ||
| + | - Ajouter un nouveau //script// dans le fichier **package.json** avec le contenu <code javascript>"scripts": { | ||
| + | // ... | ||
| + | "antlr4ts": "antlr4ts -visitor path/to/Alf.g4" | ||
| + | }</code> {{ :alf:laboratoare:packagejson.JPG?400&nolink }} | ||
| + | - Configurer le fichier **tsconfig.json**. <code json>{ | ||
| + | "compilerOptions": { | ||
| + | "target": "es2016", | ||
| + | "module": "commonjs", | ||
| + | "strict": true, | ||
| + | "esModuleInterop": true, | ||
| + | "skipLibCheck": true, | ||
| + | "forceConsistentCasingInFileNames": true, | ||
| + | "lib": ["es2016"], | ||
| + | "moduleResolution": "node" | ||
| + | } | ||
| + | }</code> | ||
| + | - Télécharger les dépendences suivantes: <code bash>npm install --save-dev @types/node | ||
| + | npm install --save-dev typescript</code> | ||
| + | |||
| + | <note important> | ||
| + | Vous pouvez lire plus de détails sur la configuration d'ANTLR4 pour TypeScript [[https://github.com/tunnelvisionlabs/antlr4ts|ici]]. | ||
| + | </note> | ||
| + | |||
| + | ===== Lexer ===== | ||
| + | |||
| + | En informatique, //l'analyse lexicale//, le //lexing// ou la //tokenisation// est le processus de conversion d'une séquence de caractères (comme dans un programme informatique) en une séquence de jetons (chaînes avec une signification attribuée et donc identifiée). Un programme qui effectue une analyse lexicale peut être appelé un **lexer**. | ||
| + | |||
| + | |||
| + | Un lexer est généralement combiné avec un //parser//, qui analysent ensemble la syntaxe des langages de programmation, des pages Web, etc. Dans ce chapitre, nous approfondirons uniquement les principes de construction d'un lexer, et nous discuterons des autres composants dans les TPs suivants. | ||
| + | |||
| + | Vous pouvez construire un lexer de deux façons: | ||
| + | * Ecrire un programme qui utilise des expressions régulières et faire correspondre ces expressions régulières à aux jetons | ||
| + | * Utilisez un générateur de lexer qui reçoit les expressions régulières et écrit le lexer pour vous | ||
| + | |||
| + | ==== Rappel - Expressions régulières ==== | ||
| + | |||
| + | === Mathematique === | ||
| ^ Character ^ Description ^ Exemple ^ | ^ Character ^ Description ^ Exemple ^ | ||
| | * | Zéro ou plusieurs fois | a*, (ab)* | | | * | Zéro ou plusieurs fois | a*, (ab)* | | ||
| Line 36: | Line 79: | ||
| | ? | Zéro ou une fois | a?, (ab)? | | | ? | Zéro ou une fois | a?, (ab)? | | ||
| | %% ^ %% | début de string | %%^%%ab* | | | %% ^ %% | début de string | %%^%%ab* | | ||
| - | | %%$%% | fin de string | b*a$ | | + | | %%$%% | fin de string | b*a%%$%% | |
| | . | tout symbole | . | | | . | tout symbole | . | | ||
| | [ ] | Ensemble | [abc] | | | [ ] | Ensemble | [abc] | | ||
| Line 44: | Line 87: | ||
| | %% | %% | Ou | a %%|%% b, (ab) %%|%% (ba) | | | %% | %% | Ou | a %%|%% b, (ab) %%|%% (ba) | | ||
| - | ==== JavaScript ==== | + | |
| + | === JavaScript === | ||
| ^ Character ^ Description ^ Exemple ^ | ^ Character ^ Description ^ Exemple ^ | ||
| | {n} | n fois | a{3} | | | {n} | n fois | a{3} | | ||
| - | | {n,m} | au moins n, au plus m | a{3,7} | | + | | {n,m} | minimum n, maximum m | a{3,7} | |
| | \w | alphanumérique et _ | \w | | | \w | alphanumérique et _ | \w | | ||
| | \t | TAB | a\ta* | | | \t | TAB | a\ta* | | ||
| - | | \n | fin de linge | a\nb | | + | | \n | fin de ligne | a\nb | |
| | \r | retour chariot | a\rb | | | \r | retour chariot | a\rb | | ||
| | a(?!b) | a seulement si non suivi par b | a(?!b) | | | a(?!b) | a seulement si non suivi par b | a(?!b) | | ||
| Line 56: | Line 100: | ||
| | ( ) | group | a(ab)a | | | ( ) | group | a(ab)a | | ||
| - | Pour déclarer des expressions régulières, on peut écrire de deux façons | + | Pour déclarer des expressions régulières, on a 2 possibilités: |
| <code javascript> | <code javascript> | ||
| - | // making a new RexEx object the standard way | + | // making a new RexExp object the standard way |
| - | var regex = new RegEx ("[0-9]+"); | + | let regex = new RegExp ("[0-9]+"); |
| // making a new RegEx object using a shortcut | // making a new RegEx object using a shortcut | ||
| - | var regex = /[0-9]+/; | + | let regex: RegExp = /[0-9]+/; |
| </code> | </code> | ||
| - | ==== Fonctions ==== | ||
| - | === String === | ||
| - | * //[[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/split|str.split(separatorRegex, limit)]]// - divise le string dans un array avec des éléments séparés //separatorRegex// | ||
| - | * //[[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/match|str.match(regex)]]// - Recherche dans le string une sous-string qui suit l'expression régulière | ||
| - | * //[[https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/search|str.search(regex)]]// - Recherche une sous-string qui correspond à l'expression régulière et renvoie l'index de celle-ci ou -1 si elle ne la trouve pas. | ||
| - | === RegEx === | + | ==== Lexer en ANTLR4 ==== |
| + | Ayant créé le projet TypeScript + ANTLR précédent, on va y ajouter un fichier **Alf.g4** avec le contenu suivant: | ||
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/exec|regex.exec(str)]]// - Recherche dans un string une sous-string qui suit l'expression régulière | + | <code> |
| - | <code javascript> | + | grammar Alf; |
| - | var regex = /([0-9]+);([A-Za-z-\. ]+);([0-9]{3,4}[A-Za-z]+)/; | + | |
| - | var match = regex.exec ('1;ANDRONIE S. Manuela - Bianca;1220F extra text'); | + | prog:; |
| - | + | ||
| - | /* | + | |
| - | match: | + | |
| - | [ '1;ANDRONIE S. Manuela - Bianca;1220F', // the full match | + | |
| - | '1', // the first group | + | |
| - | 'ANDRONIE S. Manuela - Bianca', // the second group | + | |
| - | '1220F', // the third group | + | |
| - | index: 0, // the position | + | |
| - | input: '1;ANDRONIE S. Manuela - Bianca;1220F extra text' ] // the full string | + | |
| - | */ | + | |
| + | NEWLINE : ([\r\n]+); | ||
| + | INT : ([0-9]+); | ||
| </code> | </code> | ||
| - | * //[[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp/test|regex.test(str)]]// - Recherche dans une chaîne une sous-chaîne qui suit l'expression régulière et renvoie true de celle-ci trouve un ou false sinon | + | On peut observer la définition de 2 tokens différents (à l'aide des expressions régulières), //NEWLINE// et //INT// pour les nouvelles lignes, respectivement les numéros entiers. |
| - | Pour plus de fonctions, lisez la [[https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/RegExp|documentation RegEx complète]]. | + | Après avoir créé ce fichier, on va exécuter la commande ''npm run antlr4ts'', qui va générer plusieurs fichiers //.ts//, ainsi que les fichiers ''.js'' nécessaires: |
| + | * **Lexer**: les règles de lexer sont destinées à créer des objets token correspondants | ||
| + | * **Parser**: les règles de parser sont responsables pour l'analyse du langage | ||
| + | * **Listener**: fournit des méthodes appelées indépendamment par un objet walker fourni par ANTLR | ||
| + | * **Visitor**: contient des méthodes qui doivent accompagner (walk) leurs enfants avec des appels de visite explicites | ||
| + | L'étape suivante suppose la création d'un fichier **main.ts** où l'on doit écrire la structure du programme et gestionner le fichier d'entrée: | ||
| - | ===== Exercises ===== | + | <code javascript> |
| + | import { CharStreams, CodePointCharStream, CommonTokenStream } from 'antlr4ts'; | ||
| + | import { AlfLexer } from './AlfLexer'; | ||
| + | import { AlfParser, ProgContext } from './AlfParser'; | ||
| - | Fichiers de groups: | + | // Create the lexer and parser |
| - | * [[https://github.com/UPB-FILS/alf/blob/master/TP/TP3/students1220fa.csv|1220FA]] | + | let input: string = "10\n20"; |
| - | * [[https://github.com/upb-fils/alf/blob/master/TP/TP3/students1220fb.csv|1220FB]] | + | let inputStream: CodePointCharStream = CharStreams.fromString(input); |
| - | * [[https://github.com/upb-fils/alf/blob/master/TP/TP3/students1221f.csv|1221F]] | + | let lexer: AlfLexer = new AlfLexer(inputStream); |
| + | let tokenStream: CommonTokenStream = new CommonTokenStream(lexer); | ||
| + | let parser: AlfParser = new AlfParser(tokenStream); | ||
| - | - Téléchargez le fichier des étudiants pour votre groupe. Créez un projet nodejs et écrivez dans une chaîne la ligne correspondant à votre nom (ex: var s = '17;ŞOLOT E.C. Mihaela - Sara;1220FA';). N'utilisez pas d'expressions régulières. | + | // Parse the input, where `prog` is whatever entry point you defined |
| - | - Affiche la position du prénom dans la string. (**0.2p**) | + | let tree:ProgContext = parser.prog(); |
| - | - Afficher la dernière position de ";" dans la chaîne. (**0.2p**) | + | |
| - | - Traitez la string et affichez sur une ligne seperarte le prénom, le nom, l'initiale et le groupe. (**0.6p**) | + | |
| - | - Lisez le contenu de votre fichier de groupe dans une string (voir TP 1). N'utilisez pas d'expressions régulières. | + | |
| - | - Divisez la chaîne en un tableau en utilisant le caractère de nouvelle ligne (\n) comme séparateur. (**0.4p**) | + | |
| - | - Traite chaque string du tableau et affiche sur une ligne distincte le prénom, le nom et le groupe de chaque etudiant. (**0.6p**) | + | |
| - | - Pour chaque ligne de l'exercice 2, créez un objet avec les détails de l'etudiant. Ajoutez les obejcts dans un tableau. (**1p**) | + | |
| - | - Téléchargez le fichier [[https://github.com/upb-fils/alf/blob/master/TP/TP3/passwd|passwd]] et lisez-le dans une string. Créez un tableau avec des objets contenant les informations dans le fichier. Vous pouvez trouver des détails sur le fichier [[https://www.cyberciti.biz/faq/understanding-etcpasswd-file-format/|passwd]] ici. (**1p**) | + | |
| - | - Utilisez des expressions régulières pour résoudre l'exercice 2. Vous pouvez utiliser [[https://regex101.com|RegEx101]] pour écrire l'expression régulière. (**1p**) | + | |
| - | - Utilisez des expressions régulières pour résoudre l'exercice 3. (**1p**) | + | |
| - | - Utilisez des expressions régulières pour résoudre l'exercice 4. (**1p**) | + | |
| - | - Lisez le fichier [[https://github.com/upb-fils/alf/blob/master/TP/TP3/java_errors|java_errors]] et affichez: | + | |
| - | - combien d'erreurs il y a (**0.5p**) | + | |
| - | - combien de notes il y a (**0.5p**) | + | |
| - | - Stockez les informations dans un tableau au format suivant: (**0.5p**)<code json> | + | |
| - | [ | + | |
| - | { | + | |
| - | "type":"error" or "note", | + | |
| - | "line":<line_number if it exists>, | + | |
| - | "filename":<file_name if it exists>, | + | |
| - | "description":<the error or note description> | + | |
| - | }, | + | |
| - | ... | + | |
| - | ] | + | |
| </code> | </code> | ||
| - | - Ecrivez le tableau dans un fichier (indice: JSON.stringify) (**0.5p**) | + | |
| - | - Ecrivez un programme qui reçoit en paramètre un fichier java (ex: [[https://github.com/upb-fils/alf/blob/master/TP/TP3/applet.java|applet.java]]). Lire le fichier | + | <note warning> |
| - | - afficher les bibliothèques qu'il importe (**0.3p**) | + | **ATTENTION!** Après chaque modification dans le fichier //main.js//, vous devez exécuter les commandes suivantes dans le Terminal de Visual Studio Code: |
| - | - afficher toutes les classes qu'il déclare (**0.3p**) | + | * ''npx tsc'' - pour exécuter le compilateur TypeScript |
| - | - afficher tous les clases qu'il déclare (nom et et la classe qu'il étend) (**0.1p**) | + | * ''node main.js'' - pour exécuter le fichier principal JavaScript généré |
| - | - afficher toutes les fonctions qu'il déclare (nom et type de retour) (**0.3p**) | + | </note> |
| - | - **Bonus: ** Créez un projet nodejs qui reçoit en paramètre un fichier java et crée un tableau avec des objets pour chacune des classes qu'il déclare. Chaque objet a le format suivant (**1p**): <code json> | + | |
| - | { | + | |
| - | "name":<name of class>, | + | <note important> |
| - | "extends":<name of class it extends>, | + | Après chaque modification apportée à la grammaire (fichier ''Alf.g4''), vous devez exécuter la commande suivante pour enregistrer les changements: <code bash> |
| - | "functions": [ | + | npm run antlr4ts |
| - | { | + | |
| - | "name":<function_name>, | + | |
| - | "return_type":<function_return type>, | + | |
| - | "parameters":<number of parameters> | + | |
| - | }, | + | |
| - | ... | + | |
| - | ] | + | |
| - | } | + | |
| </code> | </code> | ||
| + | </note> | ||
| + | |||
| + | ===== Exercices ===== | ||
| + | - Traitez le tableau ci-dessous a l'aide des **expressions régulières** de sorte que chaque livre devienne un objet de type Book, avec les suivantes propriétés: //titre// (string), //ISBN// (number), et //date de publication// (string). **(1p)** <code javascript> let books_array: string[] = [ | ||
| + | 'Engineering a Compiler,9780120884780,7th February 2011', | ||
| + | 'Modern Operating Systems 4,9780133591620,21st March 2014', | ||
| + | 'Computer Networks,9332518742,9th January 2010' | ||
| + | ];</code> | ||
| + | - Installez ANTLR4 globalement, ainsi que la version pour TypeScript. Attachez une capture d'écran avec l'exécution de la commande ''antlr4'' dans votre Command Prompt et une autre avec le résultat de la commande ''npm run antlr4ts'' dans le Terminal de Visual Studio Code. **(1p)** | ||
| + | - Créez le programme complet présenté dans le tutoriel de ce TP (fichiers de configuration, fichier Alf.g4, fichier main.ts) et assurez-vous que son exécution est réalisée sans d'erreurs. **(1p)** | ||
| + | - Affichez la liste des tokens: **(1p)** | ||
| + | - A l'aide des fonctions pour les strings, traitez le fichier ''Alf.tokens'' créé automatiquement par ANTLR et générez un dictionnaire qui ait comme clés l'indice de vos tokens et comme valeurs leur nom. **(0.5p)** <code bash>{ '1': 'NEWLINE', '2': 'INT' }</code> | ||
| + | - Parcourez et affichez la liste des tokens (pour chaque token, affichez son nom et sa valeur comme dans l'exemple. **Indice**: Pour pouvoir afficher la liste des tokens, vous devrez inspecter la classe //BufferedTokenStream// et choisir une méthode qui retourne cette liste. Vous aurez aussi besoin de la fonction **nextToken()** pour parcourir le buffer de données. **(0.5)** <code bash>[{ '10': 'INT', '\n': 'NEWLINE', '20': 'INT' }</code> | ||
| + | - Ajoutez a votre fichier ''Alf.g4'' des expressions régulières pour les jetons suivants: WORD - tout texte contenant uniquement des lettres et PONCTUATION - différents signes de ponctuation. Utilisez le lexer créé dans l'exercice précédent pour afficher la liste des tokens pour le texte: //Bonjour! Le TP d'ALF est de 8 a 10.// **(1p)** | ||
| + | - Utilisez votre lexer pour analyser les jetons du fichier [[https://github.com/UPB-FILS-ALF/TP/blob/main/TP3/text_and_numbers.txt|text_and_numbers.txt]]. Pour chaque ligne de ce fichier affichez le texte du jeton, le type, et la ligne du fichier ou il a été trouvé. **(1p)** | ||
| + | - Ecrivez un lexer qui reconnaît un sous-ensemble du langage Python. Pour chaque point de cet exercice, utilisez comme exemple une chaîne quelconque correspondant au langage Python, pour voir si votre programme peut: **(3p)** | ||
| + | - Reconnaître les mots-clés suivants: for, if, while, else, def, break, class | ||
| + | - Reconnaître les noms des fonctions: ils commencent par une lettre ou _ et sont suivis de n'importe quelle lettre ou chiffre | ||
| + | - Reconnaître les nombres entiers | ||
| + | - Reconnaître les nombres à reels | ||
| + | - Reconnaître les variables | ||
| + | - Reconnaître les opérateurs: ( ) , ; : + - * / = % { } [ ] | ||
| + | - Utilisez le lexer de l'exercice précédent pour le fichier ''program.py''. Ecrivez chaque type de jeton, le texte qui lui correspond et la ligne où il a été trouvé. **(1p)** | ||
| + | - **Bonus**: Modifiez le lexer de l'exercice **7** pour qu'il reconnaisse aussi des chaînes de caractères (texte encapsulé entre ” ou '). **(1p)** | ||
| - | <hidden> | ||
| - | ==== Solutions ==== | ||
| - | [[https://github.com/UPB-FILS/alf/tree/master/TP/TP3|Solutions]] | ||
| - | </hidden> | ||
