Langages et Documents Traitements des textes « sources »

Présentation au sujet: "Langages et Documents Traitements des textes « sources »"— Transcription de la présentation:

1 Langages et Documents Traitements des textes « sources »
26/03/2017 Objectif pédagogique Acquérir les techniques de bases pour la définition et le traitement « source to source » des textes des langages de programmation et des documents structurés Organisation Les cours "COMPILATION" et "LANGAGES & DOCUMENTS" partagent une introduction à la Compilation l'analyse lexicale des textes la programmation LEX.. les exemples issus de sources HTML, X(HT)ML, CSS etc. Langages et Documents Traitements des textes « sources » Langages de Programmation Documents Structurés Paul Franchi SI - 4 Langages et Documents - Traitement Lexical des Textes

2 Quelques dates Bull-CII: Mini6 PDP-11, Vax Sun, Mac PC IBM360: Batch
26/03/2017 Quelques dates Fortran, Cobol, Lisp, Algol, APL, PL/I, Basic Pascal, Simula, Algol 68 1969 Multics  Unix B  C, Prolog, Lex, Yacc DOS, TeX Scheme Green (DoD) => Ada Smalltalk, Modula 2 MS-DOS PostScript, LaTeX Lisa => Mac & Souris 1985 Windows C++ 1987 Perl, SQL 1989 ANSI C, Modula 3 Mosaic + HTML 1991 Unix  Linux, Python PDF Java, Windows AltaVista, MSN, Yahoo, etc. SGML  XML, JavaScript iTunes, iPod Google = 100 Gigas$ iPod x 275 Millions Apple = 225 Giga$ > Microsoft IBM360: Batch Bull-CII: Mini6 PDP-11, Vax Sun, Mac PC Langages et Documents - Traitement Lexical des Textes

3 Quelques dates http://www.scriptol.org/fr-dates.html
26/03/2017 Langages de programmation par dates Quelques dates 1946 Plankalkül 1949 Short Code 1951 A-0 1952 Autocode 1954 Flow-matic 1956 IPL 1957 Fortran Math-Matic 1958 Fortran II Ial 1959 Lisp 1.5 1960 Algol 60 Cobol Apl Fortran IV. . Simula 1963 Joss 1964 Apl-360 Basic PL/1 1965 Snobol 3 1966 Fortran 66 Lisp 2 Iswim 1967 Snobol 4 Simula 67 Bcpl 1968 Algol 68 Altran Cobol ANSI. Logo Refal 1969. B 1970 Forth. Pascal -CDC6000. Mumps défini. 1972 Plankalkül C. Prolog. Intercal. 1973 Comal 1974 1975 Tiny Basic Basic Altair Scheme. Ratfor 1976 futur PostScript. 1977 Mumps -ANSI. . Pascal PDP-11 IDL. Icon Bourne Shell. 1978 Awk. Fortran Rexx. 1980 Smalltalk-80 Modula-2 1981 Common LISP . 1982 ISO Pascal. Objective C. 1983 Ada. C++ Turbo Pascal. 1984 Apl 2. Clipper. 1984 Apl 2. Clipper. 1985 Postscript. 1986 Smalltalk/V Turbo Prolog. Actor. Eiffel. C++ achevé. 1987 Hypertalk. Perl. SQL Oberon Tcl. 1989 ANSI C. C Modula 3. Miranda. 1990 C Fortran 90. J. Haskell. 1991 Python. Visual Basic. 1992 Dylan. Disco. 1993 AppleScript. Self. Lua. 1994 Java. Ruby Ada 95 Php. Delphi NetRexx. JavaScript. 1997 ECMAScript. Rebol Erlang 1999 C Standard C Scharp (C#). D. 2001 Aspect J. Scriptol. SuperX Factor 2004 Php 5. Scala. Boo. Fortran, Cobol, Lisp, Algol, APL, PL/I, Basic Pascal, Simula, Algol 68 1969 Multics  Unix B  C, Prolog, Lex, Yacc DOS, TeX Scheme Green (DoD) => Ada Smalltalk, Modula 2 MS-DOS PostScript, LaTeX Lisa => Mac & Souris 1985 Windows C++ 1987 Perl, SQL 1989 ANSI C, Modula 3 Mosaic + HTML 1991 Unix  Linux, Python PDF Java, Windows AltaVista, MSN, Yahoo, etc. SGML  XML, JavaScript iTunes, iPod Google = 100 Gigas$ iPod x 275 Millions Apple = 225 Giga$ > Microsoft 2005 Scriptol Interpreter. Seed7. Langages et Documents - Traitement Lexical des Textes

4 Langages de Programmation
26/03/2017 Langages de Programmation Définition du "source" Formelle validation robustesse Opérationnelle mise en œuvre utilisation d'outils Inductive composition des traitements transportabilité évolutivité Objectif: 0-défaut "Bug-free" Analyse lexicale Traitements « source to source » Définition exacte du "source" Industriel vs artisanal Documents Structurés Prog. Déclarative (par Règles) Modèles SGML, DTD, DOM Langages HTML, XML, CSS Transformations XSLT Navigateurs Editeurs & Outils Langages et Documents - Traitement Lexical des Textes

5 Compilation Analyses Lexicale, Syntaxique, et Sémantique
26/03/2017 Objectifs pédagogiques Donner une introduction au processus de compilation dans sa partie avant. Définir les principales phases de la partie avant: analyse lexicale, syntaxique et sémantique. Donner les bases et les résultats théoriques qui fondent l ’implémentation des analyseurs lexicaux et syntaxiques. Permettre l’utilisation des générateurs de type lex et yacc Initier à l’utilisation des techniques de la compilation pour des applications « source to source », en particulier les transformations de documents. Compilation Analyses Lexicale, Syntaxique, et Sémantique Chapitres 1 & 2 Paul Franchi SI deuxième année Langages et Documents - Traitement Lexical des Textes

6 toutprogammer.com/compilers
26/03/2017 Sommaire Références bibliographiques Compilateurs: Principes, techniques et outils, A. Aho, R. Sethi, J. Ullman; InterEditions (1991) Lex & Yacc, JR Lewine, T. Mason, D. Brown; O’Reilly & Associates, Inc (1992) A first course using ANSI C, LEX and YACC, J. P. Bennett, 2nd edition, McGraw Hill (1996) Modern Compilation Implementation, A. Appel; Cambridge University Press (1998) The Essence of Compilers, R. Hunter, Prentice hall (1999) Compilateurs, D.Grune et all, Dunod (2002) Crafting a Compiler, C.Fischer, R.LeBlanc, Benjamin Cummings Series (1988) Autres Cours ESSI Petit Précis de Lex. J. Farré; Notes de TP ESSI-2 (1998) Petit Précis de Yacc. J. Farré; Notes de TP ESSI-2 (1998) Liens Web Cours de Compilation du MIT (format .ppt en Anglais) lecture3: grammaires, arbres, langages, analyseurs lecture4: construction SLR lecture5: construction LR(1) lecture6: construction LALR(1) lecture7: sémantique statique. 1. Introduction à la compilation 2. Analyse lexicale 3. Rappels sur les langages formels 4. Analyse syntaxique non déterministe 5. Analyse syntaxique descendante 6. Analyse syntaxique ascendante 7. Traduction dirigée par la syntaxe 8. Générateurs LR() 9. Sémantique statique des L.P. 10. Traitements «source to source» Lang&Doc Langages et Documents - Traitement Lexical des Textes toutprogammer.com/compilers

7 Chapitre 1 Introduction à la Compilation
26/03/2017 Autres Références sur les grammaires et les automates Introduction to Automata Theory and Computation, Hopcroft, J. Ullman, Addison Wesley (1979) An Introduction to Formal Language Theory, R. Moll, M. Arbib, A. Kfoury, Springer-Verlag, (1988) Eléments d’algorithmique, D. Beauquier, J. Berstel, P. Chrétienne, Masson (1992) Liens Web Cours de Grammaires et Automates pour l’ISIA, Paul Franchi (format .ppt en Français) Cours de Compilation du MIT (format .ppt en Anglais) lecture3: grammaires, arbres, langages, analyseurs lecture4: construction SLR lecture5: construction LR(1) lecture6: construction LALR(1) lecture7: sémantique statique. Chapitre 1 Introduction à la Compilation Historique Schéma conceptuel Phases et passes Structures et langages intermédiaires Méta-compilation Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi 7

8 Conception: modèle Analyse et Synthèse
26/03/2017 @ Conception: modèle Analyse et Synthèse Historique Les premiers compilateurs datent des années 50. Dans le contexte de l’état de l’art de l’époque, ce sont des programmes difficiles à réaliser. Le premier compilateur Fortran [Backus et al, 1957] est estimé à un travail de 18 hommes-années. Les progrès effectués en matière d’écriture de compilateurs sont considérables; ils sont dus principalement à deux causes: la compréhension et la définition formelle des tâches à réaliser, ainsi que la découverte des fondements théoriques de ces tâches qui apportent des résultats utilisables en pratique. Les avancées méthodologiques dans la production des grands logiciels, ainsi que le développement d’outils logiciels puissants et fiables. Aujourd’hui, on estime à un semestre-étudiant(e) le volume de travail nécessaire à la réalisation d’un compilateur standard; et ce, en dépit du cas particulier du langage Ada, dont le premier compilateur fut beaucoup plus difficile à valider que prévu en 1983. Modèle Analyse et Synthèse Les compilateurs actuels sont le plus souvent conçus sur le modèle Analyse et Synthèse qui consiste à dissocier deux parties distinctes: La partie Avant ou Frontale(« front-end ») qui analyse le programme source, conformément à la définition du langage compilé, indépendamment du langage cible. La partie Arrière ou Finale (« back-end ») qui produit le code généré, conformément à la définition du langage cible, indépendamment du langage source. Les deux parties communiquent entre elles via une ou plusieurs structures de données intermédiaire, le plus souvent des tables et/ou des arbres; une approche plus moderne utilise une communication de type API Java . Traduire un programme source dans un langage cible analyse le programme conformément à la définition du langage source produit d’éventuels messages d’erreurs synthétise un code équivalent au programme source dans le langage cible Schéma fonctionnel => TP LEX: API Xterm HTML Compilateur Partie Partie Avant Arrière Source Cible Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Messages d’erreurs Transparent 8

9 26/03/2017 @ Phases & Passes Logiciels cousins des compilateurs De nombreux outils logiciels analysent des programmes sources: Editeurs structurés Paragrapheurs (ou formateurs) Contrôleurs statiques Interprètes, assembleurs, éditeurs de liens, etc. Applications utilisant des techniques de compilation De nombreuses applications font appel aux techniques éprouvées de la compilation, notamment celles de la partie avant: Traitement de texte Calcul symbolique Compression et encryptage des données Navigateurs (« Browser ») Compilateurs de circuits (silicium) Passes On appelle passe, le processus consistant à parcourir en totalité, une fois, la représentation correspondant au texte source d’origine. Pendant une passe, on peut exécuter les traitements correspondant à une ou plusieurs phases de la compilation. Ces phases sont alors traitées séquentiellement ou entrelacées. Le nombre minimum de passes nécessaires à la compilation d’un langage dépend de sa définition: une seule passe pour le langage PASCAL trois passes au moins pour le langage Ada Une phase est une étape conceptuelle du processus de compilation Une passe regroupe des traitements nécessitant un parcours complet du source (ou de la représentation associée) Source A. lexicale E r e u s S y m b o l e s A. syntaxique A. sémantique G. code intermédiaire Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Optimiseur de code G. de code Cible Transparent 9

10 Phase lexicale : fonctionnalités
26/03/2017 @ Phase lexicale : fonctionnalités Fonctionnalités de l ’analyse lexicale c’est la phase 1 du processus de compilation; ses principales fonctions consistent à : lire le texte source analyser ce texte conformément à la définition lexicale du langage compilé découper le flot d’entrée en unités lexicales: mots clés ou réservés constantes entières, réelles, … identificateurs séparateurs, opérateurs, etc. éliminer certaines unités inutiles pour la compilation: espaces et caractères spéciaux, commentaires, etc. Flot d ’entrée le texte source, caractère par caractère Flot de sortie des unités lexicales ou lexèmes (« tokens ») Interactions l’analyseur lexical entretient des interactions avec les composants suivants: le gestionnaire de la table des symboles, qui mémorise et identifie les identificateurs l’analyseur syntaxique, qui reçoit le flot des lexèmes une mémorisation du texte source pour l’environnement de développement: éditeurs, messages d’erreurs, debuggers, ... Traiter le texte source à l’entrée découpe le texte en unités lexicales conformément à la définition lexicale du langage compilé élimine (éventuellement) certaines unités inutiles Schéma fonctionnel Erreurs. Lexèmes Source Arbres Anal. Lex Anal. Synt. Langages et Documents - Traitement Lexical des Textes requête SI-4– Paul Franchi Identificateurs Table Symbôles. Source instrumenté. Transparent 10

11 Phase lexicale : pourquoi la séparer de la phase syntaxique ?
26/03/2017 Phase lexicale : pourquoi la séparer de la phase syntaxique ? Processeurs Unix utilisant des expressions régulières sed – stream editor awk – pattern scanning langage grep – pattern matching for limited exp. egrep - pattern matching for extended exp. fgrep – pattern matching for string regex, regcmp – compile regular expression find, emacs, etc. Expressions Régulières sous Unix Basic RE Extended RE BRE +Concaténation , *, +, ? Internationalized RE extension du jeu de caractères Autres utilisations des Expressions Régulières Perl, Python, Java, PhP, JavaScript DTD, XPath, XSLT, etc. Avantages: Conception modulaire de l’architecture logicielle Indépendance phases/passes Performances des analyseurs en temps en mémoire Evolutivité du compilateur vis à vis du langage source Autres applications hors compilation: Traitement de texte et des documents Codage des données sécurité compression Recherche de motifs KMP Programmation spécialisée Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Transparent 11

12 Phase syntaxique Fonctions Analyse descendante récursive
26/03/2017 Phase syntaxique Fonctionnalités de l ’analyse syntaxique c’est la phase 2 du processus de compilation; ses principales fonctions consistent à : lire le flot de lexèmes issu de l’analyse lexicale analyser ce flot conformément à la définition syntaxique du langage compilé produire une donnée codant la structure syntaxique reconnue. produire d’éventuels messages en cas d’erreur de syntaxe Flot d’entrée Le flot de sortie du lexical, lexèmes par lexèmes Flot de sortie Une structure intermédiaire (arbres ou code) et d’éventuels messages d’erreurs Interactions l’analyseur syntaxique entretient des interactions avec les composants suivants: le gestionnaire de la table des symboles le gestionnaire d’erreurs syntaxiques l’analyseur sémantique qui reçoit le flot émis l’environnement de développement: éditeurs structurés, messages d’erreurs, debuggers, etc en établissant une correspondance entre le code intermédiaire et le texte source d’origine Fonctions Déterminer l’appartenance à un langage Produire un arbre (de dérivation) et d’éventuels messages d’erreurs Analyse descendante récursive multipasse de gauche à droite construction de l’arbre avec ou sans backtracking complexité : O(|règles||source|) Analyse (déterministe) descendante une seule passe de gauche à droite construction de l’arbre en descendant à partir de la racine meilleure complexité : O(|source|) Analyse (déterministe) ascendante construction de l’arbre en montant à partir des feuilles Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Transparent 12

13 Phase sémantique statique
26/03/2017 Phase sémantique statique Sémantique statique pour Ada83 le contrôle de type pour des programmes Ada comprend les opérations suivantes: importation du contexte de compilation calcul de la portée des identificateurs de l’unité de compilation calcul de la visibilité en fonction des mécanismes d’importations, de masquages, d’homonymie, et de surcharge instanciation des génériques identification, cad. résolution des noms étendus contrôle du typage Résolution de la surcharge en Ada algorithme original en 3 passes: descente, montée, descente sur l’arbre de dérivation algorithme amélioré en 2 passes: montée, descente. Résolution de l'héritage en Java, C++, Ada95 construction de la relation d'héritage résolution du typage et de la surcharge résolution des envois de messages Actions sémantiques synchronisées par A.S. compilation en une seule passe Attributs synthétisés seulement Actions sémantiques dirigées par la syntaxe compilation multipasse Attributs synthétisés et hérités Sémantique statique portée, visibilité, typage décompilation transformations au niveau du source Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Transparent 13

14 Compilation et Théories
26/03/2017 Compilation et Théories Référence de langages Définition formelle non ambiguë Systèmes générateurs Expressions régulières Grammaires Reconnaissance des programmes Déterminisme Performance (complexité) Classes de langages Automates finis Automates à pile Langages hors contexte Sémantique Spécifications exécutables & Générateurs Optimisation Langages à contexte Graphes Systèmes logiques Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Transparent 14

15 Métacompilation « compiler-compiler »
26/03/2017 @ Métacompilation « compiler-compiler » Historique et Etat de l ’art Le couple Lex & Yacc [1975 & 74] est le premier essai concluant pour réaliser un métacompilateur utilisable en pratique. Au niveau lexical: la génération est complète les performances sont quasi optimum le format rigide et la syntaxe ont mal vieilli les messages d’erreurs sont pauvres ou inexistants Au niveau syntaxique la génération se fait à partir de grammaires sous-classes des LR(1) les performances obtenues sont optimum la gestion des erreurs est problématique Au niveau sémantique la traduction est synchronisée par la syntaxe car elle est fondée sur un seul attribut synthétisé. Les originaux Lex et Yacc ont été revisités plusieurs fois, et récemment par GNU, sous le nom de Flex et Bison. Ces versions corrigent certains défauts, mais ne révolutionnent pas les produits. D’autres essais ont été réalisés dans des cadres théoriques, notamment à l’aide des Grammaires d’Attributs [Knuth, 1968] mais ces expériences de laboratoires ont manqué soit de performances, soit de diffusion, pour être réellement utilisables en pratique. Grammaire lexicale de L G E N R A T O C O M P I L A T E U R L ->  Lexical Grammaire syntaxique de L Parser Définitions & actions sémantiques L ->  Trans lator Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Transparent 15

16 Archicture des compilateurs: Evolution et autres applications
26/03/2017 Archicture des compilateurs: Evolution et autres applications Documents XML, DOM, XSLT Communication par une API intermédiaire Compilateur Partie Avant Source Edition Décompilation Cible Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Compilateur Partie Arrière Cible Transformations Cible Cible Transparent 16

17 Chapitre 2 Analyse lexicale
26/03/2017 Chapitre 2 Analyse lexicale 2.1 les bases théoriques de l’implémentation 2.2 lex: un méta_générateur lexical 2.3 lex: des exemples de base Langages et Documents - Traitement Lexical des Textes

18 Analyse lexicale : le découpage d’un source Ada
26/03/2017 @ Analyse lexicale : le découpage d’un source Ada Définition lexicale Ada norme 83 vocabulaire terminal : ISO norme bits séparateurs: caractère espace, de formatage, fin de ligne unités lexicales: 16 délimiteurs simples: & ‘  ( ) * + , - . / : ; < > = | 10 délimiteurs doubles: => .. ** := /= >= <= << >> <> 63 mots clés réservés : abort, abs, .., with, xor les identificateurs les littéraux numériques décimaux basés caractères chaînes les commentaires Règles de reconnaissance majuscules et minuscules sont confondues toute unité est reconnue « on-line » dans le flot en entrée sans recours à l’analyse syntaxique: => les opérateurs sont reconnus comme les autres délimiteurs => les opérateurs préfixés (par ex ¨+ ¨) sont reconnus comme des chaînes littérales => les attributs (par ex. first, last) et les types de base (par ex INTEGER, FLOAT) sont reconnus comme des identificateurs Use P_liste; -- lexicalement correct function ¨ + ¨ (L: out Liste) return Boolean is Aux: Liste := 0 ; begin return 1+ Card(cdr(L)) end Cardinal ; #11: P_liste Langages et Documents - Traitement Lexical des Textes <use> < id,11> <;> <function> <lch,12> <(> < id,13> <:> <out> < id,14> <)> <return> <id,4> <is> <id,15><:> < id, 14> <:=> <ce,0> <;>

19 Analyse lexicale : le découpage d’un source Java
26/03/2017 @ Analyse lexicale : le découpage d’un source Java Définition lexicale de Java vocabulaire terminal : Unicode 1.1.5 séparateurs: espace, tabulation, fin de ligne unités lexicales: 9 délimiteurs simples: [ ] { } ( ) , . ; 37 opérateurs simples ou doubles: 50 mots clés réservés : abstract , , while les identificateurs les littéraux , entiers flottants booléens référence caractères chaînes les commentaires Règles de reconnaissance majuscules et minuscules sont différenciées toute unité est reconnue « on-line » dans le flot en entrée sans recours à l’analyse syntaxique: on cherche l'unité la plus longue (reconnaissance "greedy") class Pile { // lexicalement correct public int hauteur () { if vide() return 0; return 1+ this.depile().hauteur() } #11: Pile <class> < id,11> <{> <public> <int> < id,13> <(> <)> <{> Langages et Documents - Traitement Lexical des Textes < if> < id,1> <(> <)> <return> <ce,0> <:> <return> <ce,1> <op,+> <this> <.> < id,2> <(> <)> <.> < id,13> <(> <)> <}> <}>

20 Section 2.1 les bases théoriques de l’implémentation
Quel est le facteur commun entre ? 26/03/2017 Un texte crypté Un Compilateur Section 2.1 les bases théoriques de l’implémentation Un Digicode un portable Un IHM Donjons & Dragons Expressions régulières Grammaires régulières Langages rationnels Automates finis Déterminisme Un Texte Compressé Langages et Documents - Traitement Lexical des Textes

21 Analyse lexicale : les outils de l ’implémentation
26/03/2017 Analyse lexicale : les outils de l ’implémentation Les outils théoriques: Langages réguliers: Expressions régulières lexèmes (« tokens ») Grammaires régulières symboles terminaux Automates finis: déterministes non déterministes transducteurs Les outils logiciels Les générateurs lexicaux : lex, flex, javalex, … grep, egrep, fgrep, ... sed, awk, ... Langages de programmation Grafcet, Esterel Perl, Python, Java, JavaScript, Php. Langages de Documents XPath, XSL, DTD, XSD Langages et Documents - Traitement Lexical des Textes

22 Langages Rationnels (Réguliers)
26/03/2017 Langages Rationnels (Réguliers) Propriétés des langages rationnels Théorème (définition): L est un langage rationnel ssi: L peut être défini par une expression régulière (forme de Kleene) il existe une grammaire G linéaire à gauche (à droite), et L = L(G) il existe un automate fini A qui reconnaît L  Théorème (déterminisation): Soit A un automate fini non déterministe qui reconnaît L, il existe un algorithme permettant d'obtenir un automate fini déterministe qui reconnaît L  Théorème (minimisation): Tout langage rationnel est reconnu par un automate fini déterministe minimal en nombre d'états . Cet automate est unique à un isomorphisme prés  Théorème (clôture): Les langages rationnels sont clos pour les opérations suivantes: concaténation, union, répétition, intersection, complémentaire  Théorème (décidabilité): Pour les langages rationnels, définis par une grammaire régulière G ou un automate fini A, les questions suivantes sont décidables: tester si L(G) ou L(A) est vide tester si L(G1) = L(G2) ou L(A1)=L(A2)   Remarque: On peut étendre les expressions régulières via des méta-opérateurs pour augmenter les facilités de description de l’utilisateur sans en modifier la puissance théorique (cf les définitions de lex, chap. 3) Grammaires régulières (linéaires) Expressions étendues(lex) Expressions régulières Automates finis indéterministes Automates finis déterministes Langages Rationnels Langages et Documents - Traitement Lexical des Textes

23 Implémentation des Générateurs d'Analyse Lexicale
26/03/2017 Implémentation des Générateurs d'Analyse Lexicale Processus de reconnaissance définition: un ensemble R de règles: Expk => Actionk résolution des ambiguïtés: on reconnaît le plus long motif possible (en entrée) en cas de motifs multiples, on choisit celui qui correspond au premier modèle dans l’ordre des règles Reconnaissance par Automate fini non déterministe (AFND) on construit un AFND à partir de R l ’analyseur à générer est la programmation d’un algorithme simulant le fonctionnement d’un AFND complexités dans le pire des cas: en place: O(|R|) = temps de construction de AFND en temps: O(|R| * |source|) Reconnaissance par Automate fini déterministe (AFD) on construit un AFD soit en déterminisant l’AFND ci-dessus, soit directement à partir de R l’analyseur à générer est la programmation d ’un algorithme simulant le fonctionnement d’un AFD en place: O(|2R|) = temps de construction de AFD en temps: O(|source|) Reconnaissance Paresseuse on utilise un AFD sans construire à priori l’ensemble des transitions; elles ne sont calculées que sur demande. complexités en pratique: en place: O(|R|) Source format général exemple /*exp actions */ a ; ek ak; abb ; a*b+ ; AFND AFD a 1 2  a b b  3 4 5 6  b 7 8 b a Langages et Documents - Traitement Lexical des Textes a b b 0137 247 58 68 a b b b 7 8 b a

24 Section 2.2 lex: un méta-générateur lexical
26/03/2017 Section 2.2 lex: un méta-générateur lexical Langages et Documents - Traitement Lexical des Textes

25 lex : un générateur lexical
26/03/2017 lex : un générateur lexical Généalogie Lex a été créée par les laboratoires Bell sous Unix en 1975 Il existe une version GNU dénommée Flex, qui améliore les fonctionnalités de Lex et qui peut être utilisée en mode compatible Lex. Il existe des versions spécifiques de Lex ou Flex pour : Ada Eiffel, C++ Java Entrée de lex: L’entrée de lex est une grammaire lexicale, cad un ensemble de règles lexicales associant: des expressions régulières étendues pour augmenter le confort de l’utilisateur des actions sémantiques programmées en C Sorties Lex construit un source C lex.yy.c, qui implémente un analyseur lexical sur la base d’un automate fini déterministe réduit correspondant à la grammaire lexicale donnée en entrée. La compilation du source lex.yy.c génère une fonction de découpage: yylex() Interactions avec Yacc, via la fonction yylex() avec la table des symboles, via la programmation en C Utilisations sous unix $ lex anal.lex $ flex anal.lex => lex.yy.c $ cc lex.yy.c -ll $ gcc lex.yy.c -lfl => yylex() lex est un méta-compilateur pour grammaires lexicales [ section de définitions ] %% [ section des règles: ExpReg Actions ] [ %% code de l ’utilisateur ] Sorties analyseur lexical en C: lex.yy.c une fonction de découpage: yylex() Utilisation sous unix Table Transitions AF(N)D S Y N T A X E Analyseur (N)D Langages et Documents - Traitement Lexical des Textes lex cc source.lex lex.yy.c a.out

26 Définition des Expressions régulières
26/03/2017 Définition des Expressions régulières Expressions régulières en forme de Kleene via des méta-opérateurs infixe  (pour la concaténation, le point est toujours omis en Lex) infixe | (alternative ou choix entre termes) postfixe(répétition 0 ou plusieurs fois d’un terme) ( ) pour les priorités entre opérateurs exemple: les identificateurs C Lettre_Tiret = a|b|..|z|A|..|Z|_ Lettre _Tiret _Chiffre = Lettre_Tiret | 0|..|9 Id = Lettre _Tiret  Lettre _Tiret _Chiffre  Id = (a|b|..|z|A|..|Z|_)(a|b|..|z|A|..|Z|_| 0|..|9) Expressions régulières étendues méta-opérateurs de confort [ ] pour les énumérations associées à - + pour la répétition une fois ou plus ? pour 0 ou 1 fois . comme caractère « joker » sauf \n ^ pour le complémentaire dans un [ ] exemples les chiffres: [0-9] les lettres: [a-zA-Z] les entiers: [0-9]+ les identificateurs C: [a-zA-Z_] [a-zA-Z0-9_]* les chaines de caractères sans " : \" [^ "]* \" les chaines de caractères Ada avec " : \" ([^ "] | \"\")* \" les commentaires lignes Ada: - - .* Alphabets: codes ISO, ASCII, etc Expressions régulières forme de Kleene via des méta-opérateurs (concaténation, le  est omis ) | (alternative) (répétition) ( ) exemple: les identificateurs C Id = (a|b|..|z|A|..|Z|_) (a|b|..|z|A|..|Z|_|0|..|9) Expressions régulières étendues méta-opérateurs [ ] ?  ^ " " \ exemples les entiers: [0-9]+ les identificateurs C: [a-zA-Z_] [a-zA-Z0-9_] les chaînes de caractères sans " : \" [^"] \" les commentaires lignes Java: "/ /" Attention: pas d'espace dans les expressions Lex Langages et Documents - Traitement Lexical des Textes

27 Les caractères de lex Les caractères terminaux
26/03/2017 Exemples de définitions Minuscule [a-z] Majuscule [A-Z] NonLettre [^a-zA-Z] Lettre ({Minuscule}|{Majuscule}) Chiffre [0-9] Mot {Lettre}+ Motdauplus7L {Lettre}{1, 7} Entier [0-9]+ EntierSigné (("-"|"+")?{Entier}) Exemples d’expressions (i|I)nt(eger)? /* deux formes dont un raccourci */ (c|C)har(acter)? /* avec ou sans capitale */ --.* /* les commentaires ada sur une ligne */ [ \t\n] /* des caractères à ignorer en général */ " " | \t | \n ; /* idem ci_dessus */ Quelques erreurs classiques (lexicales ou sémantiques ?) exp; reconnaît  exp; [class|public] reconnaît c l a s s p u b i | [^"class"] reconnaît tout sauf a c l s " ALPHA ({L}|{C}) les () sont obligatoires pour l’* ID {L}( {ALPHA} ) * les {} toujours MC class public =>  « unreconnizable rule » <ETAT> exp =>  « unreconnizable rule » Les caractères de lex Les caractères terminaux tous les caractères, sauf les spéciaux l ’espace est significatif les spéciaux doivent être protégés par " " ou \ Les caractères spéciaux (méta-) Pas d'espace dans les expressions Langages et Documents - Traitement Lexical des Textes

28 Méta-langage et syntaxe de Lex
26/03/2017 Méta-langage et syntaxe de Lex Définitions lex C’est l'association de symboles à des expressions étendues: Lettre [a-z A-Z] Chiffre [0-9] Alphanum ({Lettre}|{Chiffre}) Les définitions doivent tenir sur une seule ligne! Ni retour chariot, ni espace dans les expressions Syntaxe des Règles de lex Une Règle est une Expression (éventuellement associée) à une Action les Expressions commencent en début de ligne pas de commentaire en début de ligne, seulement après les Actions un espace au moins ou mieux une tabulation entre les Expressions et les Actions l’opérateur | indique que l’action associée est celle de la ligne suivante: begin | end printf(« mot clé ») ; les actions sont des instructions C qui doivent être regroupées dans un bloc instruction {} l’absence d’action ou ";" => action vide, cad: empèche la recopie par défaut de l'unité reconnue sur la sortie /* Section Définitions (optionnelle)*/ Définitions lex /* optionnelles */ /* à substituer dans les règles Lex */ %{ /* obligatoirement en début de ligne */ Définitions en langage C ou C++ /* seront insérées telles quelles dans le code généré par Lex*/ %} /* obligatoirement en début de ligne */ /* à substituer dans les règles Lex */ /* Section Règles ci-dessous: attention: commentaires ligne possibles seulement après les actions */ %% expressions lex {instructions C} /* … */ /* Section Code utilisateur (optionnelle)*/ Code C de l ’utilisateur & main() /*à insérer dans le code généré par lex*/ /* retour chariot obligatoire à la fin du flot d'entrée*/ Langages et Documents - Traitement Lexical des Textes

29 Exécution (simplifiée) d'un analyseur Lex
26/03/2017 Exécution (simplifiée) d'un analyseur Lex Compilation des définitions Lex toutes les définitions sont substituées dans les expressions régulières des règles soit R l'ensemble de règles {Ei->Ai} trié dans l'ordre du source lex Exécution des règles Lex le flot d'entrée est analysé séquentiellement de gauche à droite deux curseurs parcours le flot: CD, pour le début du lexème courant CC, pour le caractère courant on avance CC pour obtenir la plus longue chaîne possible reconnue par une expression Ei de R s'il existe plusieurs Ei possibles pour la chaîne la plus longue reconnue, on choisit la première dans l'ordre du source (Ek) on exécute les actions Ak, associées à Ek si aucune expression ne reconnaît le caractère CC, on recopie le caractère courant sur le flot de sortie. tant que le flot d'entrée n'est pas vide, les curseurs CD et CC sont positionnés à CC+1 Application aux reconnaissances lexicales on reconnaît ensemble les mots réservés, les chaînes de caractères et les commentaires dans un langage: si une chaîne contient un mot réservé, il n’est pas reconnu car la chaîne est un lexème plus long Idem pour les commentaires Et ce, quelque soit l’ordre des expressions dans le code Lex public Flot scan() { // this est un flot d'entrée Flot FSortie: new Flot(); CC=CD= debut(); while( !EOF() && ulex(CD,CC).rec() ) {CC++;} if ( !EOF() || ulex(CD,CC-1).rec() ) if (CD==CC) { FSortie.app(CC); CD=++CC;} else {exec(ulex(CD,CC-1).regle()); CD=CC;} return FSortie; } Lexème le + long possible CCCCCCCCCCCCCCCCCCCCC Langages et Documents - Traitement Lexical des Textes CD CC E1 -> A1

30 Format (non convivial!) de Lex
26/03/2017 Format (non convivial!) de Lex Espaces ou tabulations ni en début de ligne, ni dans les expressions régulières obligatoires entre expressions et actions commentaires seulement en fin de lignes dans la section Règles Substitution des { } attention aux priorités après substitution Passage à la ligne impossible dans une expression Le fichier d'entrée doit se terminer par un retour chariot Quelques erreurs classiques (lexicales ou sémantiques ?) exp; reconnaît  exp; [class|public] reconnaît c l a s s p u b i | [^"class"] reconnaît tout sauf c l a s s" ALPHA ({L}|{C}) les () sont obligatoires pour l’* ID {L}( {ALPHA} ) * les {} toujours MC class public =>  « unreconnizable rule » <ETAT> exp =>  « unreconnizable rule » Espaces ou tabulations ni en début de ligne, ni dans les expressions obligatoire entre expressions et actions commentaires dans les blocs {} seulement en fin de ligne dans les Règles Substitution des { } attention aux priorités après substitution Passage à la ligne impossible sauf | pour "factoriser" des règles Erreurs classiques exp; [public|private] ["class"] [^"class"] ALPHA ({L}|{C} ) ID {L} ( {ALPHA} ) * Langages et Documents - Traitement Lexical des Textes

31 Lex: variables, fonctions et macros
26/03/2017 Lex: variables, fonctions et macros Contexte gauche inclusif %s ASUIVRE %% ……. /* actifs aussi dans l'état ASUIVRE */ debut {BEGIN ASUIVRE ;} < ASUIVRE >suite {BEGIN 0 ;} Contexte gauche exclusif %x ASUIVRE ……. /* NON actifs dans l'état ASUIVRE */ debut {BEGIN ASUIVRE;} < ASUIVRE >suite {BEGIN INITIAL;} Analyseur lexical yylex() – la fonction d’analyse yywrap() – après l'analyse du texte en entrée Le « token » en cours char *yytext int yyleng Etats ou contexte gauche %START %s %x BEGIN R av <EXC> R ss <> ou av <INITIAL> EXC BEGIN INC BEGIN R ss <> ou av <INITIAL> Langages et Documents - Traitement Lexical des Textes

32 Lex: modifier le fonctionnement
26/03/2017 Lex: modifier le fonctionnement Recouvrement de lexèmes %% mot-composé {nmotComp++; REJECT;} mot {nmot++; REJECT;} composé {nmot++; REJECT;} => coût élevé en raison du retour arrière Redécouper avec un autre état mot {BEGIN AUTRE_ETAT; yyless(0); } Redécouper des lexèmes %% chaînes avec \ " \" [ ^ " ]* \ "   {if (yytext[yyleng-2] == ‘ \\ ’) { yyless(yyleng -1); /* garder le " */ yymore() ; /* append la suite */ } else { /* traitement de la chaîne */ } Traitement général, puis spécifique {MC} {styleMC(); ECHO; REJECT;} class {traiterClasse();} Modifier le découpage yymore() – concatène les tokens successifs yyless(int n) – retour arrière de yyleng - n REJECT – ressaye les autres reconnaissances possibles par les autres règles Entrées/Sorties de caratères input() – lit le prochain caractère output(char c) – écrit c unput(char c) – met c dans le flot d’entrée ECHO – écrit le token courant A modérer Langages et Documents - Traitement Lexical des Textes

33 Lex & flex: compléments (1)
26/03/2017 Lex & flex: compléments (1) PILE DES ETATS %s OK A B %option stack a|b {yy_push_state(OK); yy_push_state(A); } <A>a ECHO; yy_push_state(B); <B>b yy_pop_state(); BEGIN(yy_top_state() ); End Of File <QUOTE><<EOF>> { error (« quote non ferméé"); yyterminate(); } <<EOF>> {if(YY_START==OK) printf("OK\n"); else printf("KO\n"); yyterminate(); } Sur les Etats INITIAL ou 0 <*> – tous les états, y compris 0 <A,B,C> – «start conditions» multiples <A> { Exp1 R1 ; Expn Rn ; } – règles multiples YY_START – l’état courant YYSTATE Avec une (la) pile des états %option stack – accès à la pile des états yy_push_state(s), _pop_ => BEGIN yy_top_state() # de YY_START <<EOF>> <<EOF>> – règle spéciale sur fin de fichier yyterminate() – fin d’analyse yyin=fopen(*fliste, «r») – chang. de fichier Attention: Exemples sans vraie signification Attention: Restrictions sur <<EOF>> Langages et Documents - Traitement Lexical des Textes

34 Exécution d'un analyseur Lex
26/03/2017 Exécution d'un analyseur Lex Compilation des définitions Lex "Preprocessing" toutes les définitions sont substituées dans les expressions régulières des règles "Base de Règles" soit R l'ensemble de règles {Ei->Ai} trié dans l'ordre du source lex Exécution des règles Lex le flot d'entrée est analysé séquentiellement de gauche à droite au départ, l'analyseur est dans l'état INITIAL ou 0 Itération on évalue la Base de Règles "ACTIVES" RA pour l'Etat Courant deux curseurs parcours le flot: CD, pour le début du lexème courant CC, pour le caractère courant on avance CC pour obtenir la plus longue chaîne possible reconnue par une expression Ei de RA s'il existe plusieurs Ei possibles pour la chaîne la plus longue reconnue, on choisit la première dans l'ordre du source (Ek) on exécute les actions Ak, associées à Ek, y compris d'éventuels changements d'Etat (par BEGIN ou yy_push_state) retour arrière par REJECT modification des entrées/sorties par yyless, yymore arret par yyterminate() si aucune expression ne reconnaît le caractère CC, on recopie le caractère courant sur le flot de sortie. tant que le flot d'entrée n'est pas vide, les curseurs CD et CC sont positionnés à CC+1 Application aux reconnaissances lexicales on reconnaît ensemble les mots réservés, les chaînes de caractères et les commentaires dans un langage: si une chaîne contient un mot réservé, il n’est pas reconnu car la chaîne est un lexème plus long Idem pour les commentaires Et ce, quelque soit l’ordre des expressions dans le code Lex Lexème le + long possible CCCCCCCCCCCCCCCCCCCCC CD CC E1 -> A1 REJECT yyless() yymore() yyterminate() état valide "désarmées" BEGIN yy_pop_ yy_top_ yy_push_ YY_USER_ Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi état invalide Transparent 34

35 Lex & flex: compléments (2)
26/03/2017 Lex & flex: compléments (2) voir échappements caractères \176 // le caractère ~ en Octal \x7E // le caractère ~ en Hexa options de matching: i –i (casse) x –x (blancs) s –s(retour chariot dans .) (?i:ab7) == ([aA][bB]7) (?-i:aB) == (aB) (?x:a b) == ("ab") (?x:a\ b) == (?x:a" "b) == ("a b") (?s:.) == [\x00-\xFF] (?-s:.) == [^\n] (?ix-s:a . b) == ([Aa][^\n][bB]) classes de caractères [:alpha:] [:upper:] [:lower:] [:xdigit:] [[:alnum:]] == [[:alpha:][:digit:]] == [a-zA-Z0-9] [[:blank:] [:punct:]] // des séparateurs négation de classes [:^alpha:] échappements caractères \176 // le caractère ~ en Octal \x7E // le caractère ~ en Hexa options de "pattern matching" i et -i – sensibilité à la casse x et -x – ignore les blancs et commentaires s et -s – . avec ou sans \n classes caractères [:digit:] – comme 0-9 [:alnum:] – comme 0-9a-zA-Z [[:digit:][:alpha:]] – comme [0-9a-zA-Z] [[:^digit:]] – comme [^0-9] Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Transparent 35

36 Lex & flex: compléments (3)
26/03/2017 Lex & flex: compléments (3) Options LEX /* LEX gère la ligne courante */ %option yylineno /* pour utiliser la pile des états LEX */ %option stack YY_USER_ // routine à exécuter avant le début de l'analyse LEX #define YY_USER_INIT printf("#Règles: %d\n",YY_NUM_RULES); // routine à exécuter avant chaque action LEX (règle reconnue) #define YY_USER_ACTION printf("Règle active: %d =>", yy_act); La ligne courante %option yylineno – gestion de la ligne courante Sur les règles de l’analyseur yy_act – le numéro de la règle activée YY_NUM_RULES – le nombre total de règles Routines Utilisateur YY_USER_INIT – à faire avant l’analyse YY_USER_ACTION -- à faire à chaque règle Fichiers *yyin – FILE en entrée *yyout – FILE en sortie yyrestart (FILE *new_file) – FILE Langages et Documents - Traitement Lexical des Textes SI-4– Paul Franchi Transparent 36

37 Compléments FLEX pour les Buffers multiples
26/03/2017 Compléments FLEX pour les Buffers multiples #include en lex avec les buffers multiples %{ #define MAX_INCL 10 // version récursive int incl_stack_ptr= 0 ; YY_BUFFER_STATE incl_stack[MAX_INCL] ; %} FILENAME [a-zA-Z0-9$_\/.\-]+ %x INCL %% \#include[ \t]+\" {BEGIN INCL;} <INCL>\"[ \t\n]+ {BEGIN 0;} <INCL> {FILENAME} { if (incl_stack_ptr >= MAX_INCL) {fprintf( stderr, "Trop d'includes "); exit(1);} incl_stack[incl_stack_ptr++] = YY_CURRENT_BUFFER; yyin = fopen(yytext, "r"); if (!yyin) {fprintf( stderr, "\nImpossible d'ouvrir le fichier%s\n", yytext); exit(1);} yy_switch_to_buffer(yy_create_buffer(yyin, YY_BUF_SIZE) ); BEGIN 0; } <<EOF>> { if (--incl_stack_ptr < 0) yyterminate(); else { yy_delete_buffer(YY_CURRENT_BUFFER); yy_switch_to_buffer( incl_stack[incl_stack_ptr] ); } BEGIN INCL; // pas encore vu la fin" de #include YY_BUFFER_STATE YY_CURRENT_BUFFER yy_create_buffer() YY_BUFFER_STATE yy_create_buffer ( FILE *f, int size) yy_switch_to_buffer() void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer) yy_delete_buffer() void yy_delete_buffer ( YY_BUFFER_STATE buffer) yy_flush_buffer() void yy_flush_buffer Langages et Documents - Traitement Lexical des Textes

38 Section 2.3 Lex: des exemples de base
26/03/2017 Section 2.3 Lex: des exemples de base Identificateurs, mots clés, commentaires, chaînes de caractères, des L.P. Langages et Documents - Traitement Lexical des Textes

39 lex : les identificateurs Ada
26/03/2017 lex : les identificateurs Ada Vocabulaire utilisé lettre majuscule: + lettre minuscule + chiffre + tiret Définition commence par (au moins) une lettre continue par 0 ou plusieurs caractères alphanumériques qui peuvent être précédés par un tiret Identificateurs corrects X X1 Xx X_11 X _X_x Identificateurs incorrects X+ 1X _X X_ X__X Expression étendue: [a-zA-Z](_?[a-zA-Z0-9])* Source lex /* définitions lex*/ LET [a-zA-Z] CHIF [0-9] ALPNUM ({LET}|{CHIF}) %% /* règle sans action*/ {LET}(_?{ALPNUM})* ; %% Id2 l | c _ l Ident l | c Langages et Documents - Traitement Lexical des Textes

40 lex : les identificateurs Java
26/03/2017 lex : les identificateurs Java Vocabulaire utilisé lettre majuscule + lettre minuscule + chiffre + tiret +dollar Définition commence par (au moins) une lettre ou tiret ou dollar continue par 0 ou plusieurs caractères alphanumériques Identificateurs corrects X X1 Xx _X_11 $_X__ Identificateurs incorrects X+ 1X Expression étendue: [a-zA-Z_$ ] [a-zA-Z0-9_$] * Source lex /* définitions */ LET [a-zA-Z_$] CHIF [0-9] ALPNUM ({LET}|{CHIF}) %% /* règle sans action*/ {LET}({ALPNUM}) * ; %% l | $ | _ Ident l | c| $ | _ Langages et Documents - Traitement Lexical des Textes

41 lex : les chaînes de caractères en Ada
26/03/2017 lex : les chaînes de caractères en Ada Vocabulaire utilisé tout l’alphabet sauf \n Définition commence par  " continue par 0 ou plusieurs caractères : chaque " dans la chaîne doit être doublé "" ne contient pas de fin de ligne se termine par " Reconnaissance correcte "" " " "xxxxxx xx xxxxx " """" " """" " Reconnaissance incorrecte "xxxxxx"+++" xx"++" xxxxx " "xxxx xx" Expression ambigüe: ".  " => accepte tous les caractères sur une ligne, y compris donc plusieurs " avant le " le plus à droite => ambiguïté: " chaine1 " ++ " chaine2 "   ++ " chaine3 " Expression correcte %% /* règle sans action*/ \" ( [^ " \n ] | \" \" ) \" ; %% Err \n " " Ch . | "" Langages et Documents - Traitement Lexical des Textes

42 lex : les chaînes de caractères en C et Java
26/03/2017 lex : les chaînes de caractères en C et Java Vocabulaire utilisé tout l’alphabet Définition commence par  " continue par 0 ou plusieurs caractères : chaque " dans la chaîne doit être backslashé \" se termine par " qui ne doit pas être backslashé Reconnaissance correcte "" " " "xxxxx xx xxxx " "\"" " \"\" " "xxxx xx" Reconnaissance incorrecte "xxxxxx"+++" xx"++" xxxxx " " \\" " " \" Expression ambigüe: ".  " => accepte tous les caractères sur une ligne, y compris donc plusieurs " avant le " le plus à droite => ambiguïté: " chaine1 " ++ " chaine2 "   ++ " chaine3 " Expression correcte %% /* règle sans action*/ %% Langages et Documents - Traitement Lexical des Textes

43 lex : les chaînes de caractères en C et Java
26/03/2017 lex : les chaînes de caractères en C et Java Vocabulaire utilisé tout l’alphabet Définition commence par  " continue par 0 ou plusieurs caractères : chaque " dans la chaîne doit être backslashé \" se termine par " qui ne doit pas être backslashé Reconnaissance correcte "" " " "xxxxx xx xxxx " "\"" " \"\" " " \\\" \\" Reconnaissance incorrecte "xxxxxx"+++" xx"++" xxxxx " " \\" " " \" Expression ambiguë: ".  " => accepte tous les caractères sur une ligne, y compris donc plusieurs " avant le " le plus à droite => ambiguïté: " chaine1 " ++ " chaine2 "   ++ " chaine3 " Expression presque correcte %% /* règle sans action*/ \" ( [ ^" ] | \ \ \" ) \" ; %% Expression correcte \" ( [ ^" \\] | \ \ (.|\n) ) \" ; [^"\\] " " Cha \ . | \n Sla AFD Langages et Documents - Traitement Lexical des Textes

44 lex : mots clés, entiers, identificateurs C
26/03/2017 lex : mots clés, entiers, identificateurs C Quelques mots clés de C (en minuscules obligatoirement): auto | extern | static | typedef | register | short | int | long | char | float | double | struct | union | sizeof | if | else | do | while | for | case | switch | default | return | break | continue | goto Les identificateurs de C (en minuscules ou majuscules): commence par une Lettre ou un Tiret se poursuit éventuellement par une Lettre , un Chiffre ou un Tiret Source lex CHIF [0-9] ENTSIG ("-"|"+")?{CHIF} + IDENT [a-zA-Z_][a-zA-Z_0-9] MC1 auto | extern | static | typedef | register MC2 short | int | long | char | float | double MC3 if | else | do | while | for | case | switch MC default | return | break | continue | goto MC {MC1} | {MC2} | {MC3} | {MC4} %% {ENTSIG} {printf("%d\n", atoi(yytext)) ;} {IDENT} {printf("%s\n", yytext) ;} {MC} {printf( "mclé: %s\n", yytext) ;} [ \t\n]+ ; /* caractères ignorés */ {fprintf(stderr, "car. invalide: %s\n", yytext) ;} Langages et Documents - Traitement Lexical des Textes

45 lex : les commentaires en C forme /* */
26/03/2017 lex : les commentaires en C forme /* */ Commentaires en C(/* */) texte entre entre /* et */ sur une ou plusieurs lignes ne contiennent pas */ mais peuvent contenir * si pas suivie de / Automate Fini ND Automate Fini D Expression ambiguë: " / " .  "/ " => accepte tous les caractères dans le commentaire, y compris donc plusieurs / avant le / le plus à droite => ambiguïté: /com1/ ++ /com2/  ++ /com3/ Expression Régulière Lex Source lex (avec un état exclusif) %x COM %% AFND */ /* COM . | \n / /* * COM ET AFD * tout sauf * tout sauf * et / Langages et Documents - Traitement Lexical des Textes ? ?

46 lex : les commentaires en C forme /* */
26/03/2017 lex : les commentaires en C forme /* */ Commentaires en C(/* */) texte entre entre /* et */ sur une ou plusieurs lignes ne contiennent pas */ mais peuvent contenir * si pas suivie de / Automate Fini ND Automate Fini D Expression ambiguë: " / " .  "/ " => accepte tous les caractères dans le commentaire, y compris donc plusieurs / avant le / le plus à droite => ambiguïté: /com1/ ++ /com2/  ++ /com3/ Expression Régulière Lex " / " ( [^] | ("")+ [^/] ) ("")+ " / " Source lex (avec un état exclusif) %x COM %% " / " {BEGIN COM;} <COM> "/ " {BEGIN 0;} <COM> .| \n ; AFND */ /* COM . | \n / /* * COM ET AFD * tout sauf * tout sauf * et / Langages et Documents - Traitement Lexical des Textes ? ?

47 lex : les commentaires en C forme /* */
26/03/2017 lex : les commentaires en C forme /* */ Commentaires en C(/* */) texte entre entre /* et */ sur une ou plusieurs lignes ne contiennent pas */ mais peuvent contenir * si pas suivie de / Automate Fini ND Automate Fini D Expression ambiguë: " / " .  "/ " => accepte tous les caractères dans le commentaire, y compris donc plusieurs / avant le / le plus à droite => ambiguïté: /com1/ ++ /com2/  ++ /com3/ Expression correcte Source lex(avec un état inclusif) %s COM %% AFND */ /* COM . | \n / /* * COM ET AFD * tout sauf * tout sauf * et / ? Langages et Documents - Traitement Lexical des Textes ? ?

48 lex : les commentaires en C forme /* */
26/03/2017 lex : les commentaires en C forme /* */ Commentaires en C(/* */) texte entre entre /* et */ sur une ou plusieurs lignes ne contiennent pas */ mais peuvent contenir * si pas suivie de / Automate Fini ND Automate Fini D Expression ambiguë: " / " .  "/ " => accepte tous les caractères dans le commentaire, y compris donc plusieurs / avant le / le plus à droite => ambiguïté: /com1/ ++ /com2/  ++ /com3/ Expression correcte " / " ( [^] | ("")+ [^/] ) ("")+ " / " Source lex(avec un état inclusif) %s COM %% <INITIAL> " / " {BEGIN COM;} <COM> "/ " {BEGIN 0;} <COM> .| \n ; AFND */ /* COM . | \n / /* * COM ET AFD * tout sauf * tout sauf * et / ? Langages et Documents - Traitement Lexical des Textes ? ?

49 Unités lexicales imbriquées en lex
26/03/2017 Unités lexicales imbriquées en lex Reconnaissance imbriquées ou non ? Mots réservés et identificateurs Mots réservés dans/hors les commentaires Mots réservés dans/hors les chaînes Chaînes dans/hors les commentaires etc. Reconnus ou pas ? MC if | else | do | while | for | case | switch %s COM /* ou %x ? */ %% {MC} {printf( "mclé: %s\n", yytext) ;} ? Langages et Documents - Traitement Lexical des Textes

50 Unités lexicales imbriquées en lex
26/03/2017 Unités lexicales imbriquées en lex Reconnaissance imbriquées ou non ? Mots réservés et identificateurs Mots réservés dans/hors les commentaires Mots réservés dans/hors les chaînes Chaînes dans/hors les commentaires etc. Reconnus ou pas ? MC if | else | do | while | for | case | switch %s COM /* ou %x ? */ %% {MC} {printf( "mclé: %s\n", yytext) ;} "/*"   {BEGIN COM; ECHO;} <COM>.|\n ECHO; <COM>"*/"   {BEGIN 0; ECHO;} ? Langages et Documents - Traitement Lexical des Textes

51 lex : supprimer les espaces sauf dans les chaînes (1)
26/03/2017 lex : supprimer les espaces sauf dans les chaînes (1) Automate Fini ND pour les chaînes Avec un état exclusif %x CHA %% Attention: les règles 2, 3 et 4 ne sont activables que dans l'état <CHA> dans l'état <CHA>, le lexeme \" est reconnu par la règle 4 et non pas 1 les règles 1, 5 et 6 ne sont pas activées dans l'état <CHA> hors de l'état <CHA>, " " est reconnu par la règle 5 et non pas 6 AFND " " Cha . | \n ? ? Langages et Documents - Traitement Lexical des Textes

52 lex : supprimer les espaces sauf dans les chaînes (1)
26/03/2017 lex : supprimer les espaces sauf dans les chaînes (1) Automate Fini ND pour les chaînes Avec un état exclusif %x CHA %% \" {ECHO; BEGIN CHA;} <CHA> " " ECHO; <CHA> \" {ECHO; BEGIN 0;} <CHA> \\\" ECHO; " " ; . | \n ECHO; Attention: les règles 2, 3 et 4 ne sont activables que dans l'état <CHA> dans l'état <CHA>, le lexeme \" est reconnu par la règle 4 et non pas 1 les règles 1, 5 et 6 ne sont pas activées dans l'état <CHA> hors de l'état <CHA>, " " est reconnu par la règle 5 et non pas 6 AFND " " Cha . | \n ? ? Langages et Documents - Traitement Lexical des Textes

53 lex : supprimer les espaces sauf dans les chaînes (2)
26/03/2017 lex : supprimer les espaces sauf dans les chaînes (2) Automate Fini ND pour les chaînes Automate Fini D équivalent Avec un état inclusif %s CHA %% Attention: la règle 1 n'est activable que dans l'état <0> les règles 2, 3 et 4 ne sont activables que dans l'état <CHA> dans l'état <CHA>, le lexeme \" est reconnu par la règle 4 et non pas 1 les règles 5 et 6 sont activables dans tous les états un lexeme " " est reconnu par la règle 2 dans l'état <CHA> et par la régle 5 sinon ? Langages et Documents - Traitement Lexical des Textes

54 lex : supprimer les espaces sauf dans les chaînes (2)
26/03/2017 lex : supprimer les espaces sauf dans les chaînes (2) Automate Fini Déterministe pour les chaînes chaînes correctes: " \\ " " \\\" " chaînes incorrectes: " \" " \\\ " Avec un état inclusif %s CHA %% <INITIAL>\" {ECHO; BEGIN CHA;} <CHA> " " ECHO; <CHA> \" {ECHO; BEGIN 0;} <CHA> \\\" ECHO; " " ; . | \n ECHO; Attention: la règle 1 n'est activable que dans l'état <0> les règles 2, 3 et 4 ne sont activables que dans l'état <CHA> dans l'état <CHA>, le lexeme \" est reconnu par la règle 4 et non pas 1 les règles 5 et 6 sont activables dans tous les états un lexeme " " est reconnu par la règle 2 dans l'état <CHA> et par la régle 5 sinon " " \ CHA SLA tout sauf \ et " . | \n ? ? Langages et Documents - Traitement Lexical des Textes

55 lex : compter les éléments d’un texte
26/03/2017 lex : compter les éléments d’un texte Spécification: lire un texte en entrée reconnaître les mots comme des suites de caractères séparées par des espaces ou des tabulations ou des fins de ligne décompter les mots et les lignes lus dans le texte décompter tous les caractères y compris les caractères spéciaux: espaces, tabulations, fin de ligne. Source lex %{ static int nbCar = 0, nbMot = 0, nbLig = 0; %} MOT [^ \t\n]+ EOL \n %% {MOT} {nbMot++; nbCar +=yyleng;} {EOL} {nbLig++; nbCar ++;} . nbCar ++; main() { yylex(); printf(« %d %d %d\n », nbLig, nbMot, nbCar); } Langages et Documents - Traitement Lexical des Textes

56 Section 2.4 Traitement lexical des Textes par Expressions régulières
26/03/2017 Processeurs Unix utilisant des expressions régulières sed – stream editor awk – pattern scanning langage grep – pattern matching for limited exp. egrep - pattern matching for extended exp. fgrep – pattern matching for string regex, regcmp – compile regular expression find emacs etc. Autres utilisations des Expressions Régulières Perl, Python, Java PhP, JavaScript Dreamweaver DTD, XPath, XSD, XSLT, etc. Section 2.4 Traitement lexical des Textes par Expressions régulières awk, grep, find, emacs, etc. Java Python Perl JavaScript Langages et Documents - Traitement Lexical des Textes

57 Perl Compatible Regular Expression
26/03/2017 Expressions grep -E -P Exemples sous egrep egrep '[A-Z][a-zA-Z]{5,}' Noms.txt /* lignes qui contiennent des noms de 6 lettres au moins commençant par une majuscule */ egrep '([a-zA-Z]+)\1' Noms.txt /* lignes qui contiennent des mots de la forme ww */ egrep '([a-zA-Z]+).\1' Noms.txt /* lignes qui contiennent des mots de la forme wxw */ egrep -c '<[^<>]+>' Source.html /* compter les balises html */ egrep -c '<[^/\!][^<>]+>' Source.html /* compter les balises ni fermantes ni commentaires */ Standard POSIX (voir Wikipédia) [:space:] [:blank:] [:punct:] [:alpha:] [:lower:] [:upper:] [:digit:] [:alnum:] Options sous grep > grep -E /* expressions étendues comme egrep */ grep -P /* expressions Perl ou PCRE*/ Perl Compatible Regular Expressions sous Emacs \( \) \| Wikipédia POSTFIX ou PCRE Perl Compatible Regular Expression Langages et Documents - Traitement Lexical des Textes

58 Java Le Paquetage Java.util.regex Expressions régulières String expreg
26/03/2017 Java modèle de code Java à compléter // ici conversion Franc-Euro import java.util.regex.Pattern; import java.util.regex.Matcher; public class ConversionMonnaie { String expreg = "([0-9]+\\.[0-9]{2})([FE])"; String monnaie; float montant; Pattern p = Pattern.compile(expreg); Matcher m = p.matcher(args[0]); try { if (m.find()) { montant = (newFloat(m.group(1))).floatValue(); monnaie = m.group(2) ; // etc. Le Paquetage Java.util.regex Expressions régulières String expreg java.util.regex.Pattern Pattern p = Pattern.compile(expreg) java.util.regex.Matcher Matcher m = p.matcher( ) m.find() m.group() Langages et Documents - Traitement Lexical des Textes

59 Python Le Module re expreg = re.compile(' … ') m = expreg .match(… )
26/03/2017 Python modèle de code Python à compléter // ici conversion Franc-Euro import re ; expreg = re.compile('([0-9]+\.[0-9]{2})([FE])') m = expreg .match(line) if m : montant = m.group(1) monnaie = m.group(2) ; // etc. Le Module re expreg = re.compile(' … ') m = expreg .match(… ) if m m.group( …) Langages et Documents - Traitement Lexical des Textes

60 Expressions Perl (1) Exemples sous Perl
26/03/2017 Expressions Perl (1) Exemples sous Perl perl -ne 'print if/[A-Z][a-zA-Z]{5,}/;' Noms.txt /* imprime les lignes qui contiennent des noms de 6 lettres au moins commençant par une majuscule */ perl -ne 'print if /([a-zA-Z]+)\1//;' Noms.txt des mots de la forme ww en les effaçant*/ Langages et Documents - Traitement Lexical des Textes

61 Expressions Perl (2) Les Opérateurs sur Exp. Reg. pattern matching (m)
26/03/2017 Expressions Perl (2) Exemples sous Perl perl -ne 'tr/a-z/A-Z/;print;' Noms.txt /* imprime le fichier en majuscules */ perl -ne 'print if m&[A-Z][a-zA-Z]{5,}&;' Noms.txt /* imprime les lignes qui contiennent des noms de 6 lettres au moins commençant par une majuscule */ perl -ne 'print if s/([a-zA-Z]+)\1//;' Noms.txt /* imprime les lignes qui contiennent des mots de la forme ww en les effaçant*/ Conversion de monnaie (script partiel) $reponse=<STDIN> ; chomp($reponse); // enlève le \n final if ( $reponse = ~ m/[0-9]+\.[0-9]{2}) ([FE])/ ) { $montant = $1 ; $monnaie = $2 ; // etc. Les Opérateurs sur Exp. Reg. pattern matching (m) /[0-9]/ m$[0-9]$ substitution(s) s+new+old+ s/0/1/ character translation (tr ou y) tr/A-Z/a-z/ pattern binding (~) $nom =~/Paul/ $nom !~/Paul/ $liste =~ s/Paul/Pierre/g $liste =~ tr/A-Z/a-z/ Langages et Documents - Traitement Lexical des Textes

62 JavaScript 1.5 et + (ECMAScript)
26/03/2017 JavaScript 1.5 et + (ECMAScript) replace avec des "exp reg" function SyntaxColored(js){ if (!js || !js.replace) return ""; js=js.replace(/\r/g,'\n'); js=js.replace(/</g,'<').replace(/>/g,'>'); var parens = /([\]\[(){}]+)/g; var comments = /(\/\/.+|\/\*(.|\n)+?\*\/)/g; var keywords = /\b(function|var|if|isNaN|return|if|else|for|while|new|continue|switch|case|true|false|prototype|constructor|caller|Number|Date|Object|String|Function|Array|RegExp|Boolean|Math)\b/g; var strings = /((["'])(?:.*?(?:[^\\](?:\\\\)*|[^\\]))?\2)/g; var numbers = /\b(-?(?:\d+|\d*\.\d+)\b)/g; js=js.replace(strings,'<span class="string">$1<\/span>'); js=js.replace(parens,'<span class="paren">$1<\/span>'); js=js.replace(numbers,'<span class="number">$1<\/span>'); js=js.replace(keywords,'<span class="keyword">$1<\/span>'); js=js.replace(comments,'<span class="comment">$1<\/span>'); if (document.all) js=js.replace(/\n/g,"<br>").replace(/ /g,"  ").replace(/\t/g,"    "); //IE-specific hack js=js.replace(/<\/span>\n/g,"<\/span> \n"); return js; } Les expressions (Ecmascript v3, Perl 5 ) la classe RegExp var motif=/finADroite$/i; var motif=new RegExp("finADroite$", i); méthodes match() substr() replace() split() Modes i (ignorer la casse) g (global, donc toutes les occurrences) Répétition non avide (not "greedy") ?? +? *? Groupe seulement (non numéroté) (? : Langages et Documents - Traitement Lexical des Textes

63 Un modèle d'architecture partie avant  partie arrière
26/03/2017 Un modèle d'architecture partie avant  partie arrière Règles Règles lexicales YACC XSL Lex "Back ends" "Front ends" L. P. API S t y l e s Code C vers Xterm Enjoliveur Machines Virtuelles vers HTML HTML D O C Code C DOM API vers XML Transformateur XML Langages et Documents - Traitement Lexical des Textes