La présentation est en train de télécharger. S'il vous plaît, attendez

La présentation est en train de télécharger. S'il vous plaît, attendez

1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.

Présentations similaires


Présentation au sujet: "1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés."— Transcription de la présentation:

1

2 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI Langages de Programmation Documents Structurés

3 Transparent 2 Quelques dates n Fortran, Cobol, Lisp, Algol, APL, PL/I, Basic n 1968 Pascal, Simula, Algol 68 n 1969Multics Unix n 1972 B C, Prolog, Lex, Yacc n 1974 DOS, TeX n 1975 Scheme n Green (DoD) => Ada n 1980 Smalltalk, Modula 2 n 1981 MS-DOS n 1982 PostScript, LaTeX n 1984 Lisa => Mac & Souris n 1985Windows n C++ n 1987Perl, SQL n 1989ANSI C, Modula 3 n 1990 Mosaic + HTML n 1991Unix Linux, Python n 1993 PDF n 1995 Java, Windows n 1995-AltaVista, MSN, Yahoo, etc. n 1996 SGML XML, JavaScript n 2004 iTunes, iPod n 2008 Google = 100 Gigas$ n 2010 iPod x 275 Millions n 2010 Apple = 225 Giga$ > Microsoft

4 Transparent 3 Quelques dates n Fortran, Cobol, Lisp, Algol, APL, PL/I, Basic n 1968 Pascal, Simula, Algol 68 n 1969Multics Unix n 1972 B C, Prolog, Lex, Yacc n 1974 DOS, TeX n 1975 Scheme n Green (DoD) => Ada n 1980 Smalltalk, Modula 2 n 1981 MS-DOS n 1982 PostScript, LaTeX n 1984 Lisa => Mac & Souris n 1985Windows n C++ n 1987Perl, SQL n 1989ANSI C, Modula 3 n 1990 Mosaic + HTML n 1991Unix Linux, Python n 1993 PDF n 1995 Java, Windows n 1995-AltaVista, MSN, Yahoo, etc. n 1996 SGML XML, JavaScript n 2004 iTunes, iPod n 2008 Google = 100 Gigas$ n 2010 iPod x 275 Millions n 2010 Apple = 225 Giga$ > Microsoft

5 Transparent 4 Langages de Programmation Analyse lexicale Traitements « source to source » Documents Structurés Modèles SGML, DTD, DOM Langages HTML, XML, CSS Transformations XSLT Navigateurs Editeurs & Outils

6 5 Compilation Analyses Lexicale, Syntaxique, et Sémantique Paul Franchi SI deuxième année Chapitres 1 & 2

7 Transparent 6 Sommaire 1. Introduction à la compilationIntroduction à la compilation 2. Analyse lexicaleAnalyse lexicale 3. Rappels sur les langages formelsRappels sur les langages formels 4. Analyse syntaxique non déterministeAnalyse syntaxique non déterministe 5. Analyse syntaxique descendanteAnalyse syntaxique descendante 6. Analyse syntaxique ascendanteAnalyse syntaxique ascendante Traduction dirigée par la syntaxe 8. Générateurs LR() 9. Sémantique statique des L.P. 10. Traitements «source to source»

8 7 Chapitre 1 Introduction à la Compilation n Historique n Schéma conceptuel n Phases et passes n Structures et langages intermédiaires n Méta-compilation

9 Transparent 8 Compilateur Partie Avant Arrière Source Messages derreurs Cible Conception: modèle Analyse et Synthèse n Traduire un programme source dans un langage cible analyse le programme conformément à la définition du langage source produit déventuels messages derreurs synthétise un code équivalent au programme source dans le langage cible n Schéma fonctionnel

10 Transparent 9 A. lexicale Source Cible Phases & Passes n Une phase est une étape conceptuelle du processus de compilation n Une passe regroupe des traitements nécessitant un parcours complet du source (ou de la représentation associée) A. syntaxique A. sémantique G. code intermédiaire Optimiseur de code G. de code SymbolesSymboles ErreursErreurs

11 Transparent 10 Table Symbôles. Anal. LexAnal. Synt. Lexèmes Source Identificateurs Arbres requête Phase lexicale : fonctionnalités n Traiter le texte source à lentrée découpe le texte en unités lexicales conformément à la définition lexicale du langage compilé élimine (éventuellement) certaines unités inutiles n Schéma fonctionnel Erreurs. Source instrumenté.

12 Transparent 11 Phase lexicale : pourquoi la séparer de la phase syntaxique ? n Avantages: Conception modulaire de larchitecture logicielle Indépendance phases/passes Performances des analyseurs en temps en mémoire Evolutivité du compilateur vis à vis du langage source n 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

13 Transparent 12 Phase syntaxique n Fonctions Déterminer lappartenance à un langage Produire un arbre (de dérivation) et déventuels messages derreurs n Analyse descendante récursive multipasse de gauche à droite construction de larbre avec ou sans backtracking complexité : O(|règles| |source| ) n Analyse (déterministe) descendante une seule passe de gauche à droite construction de larbre en descendant à partir de la racine meilleure complexité : O(|source|) n Analyse (déterministe) ascendante une seule passe de gauche à droite construction de larbre en montant à partir des feuilles meilleure complexité : O(|source|)

14 Transparent 13 Phase sémantique statique n Actions sémantiques synchronisées par A.S. compilation en une seule passe Attributs synthétisés seulement n Actions sémantiques dirigées par la syntaxe compilation multipasse Attributs synthétisés et hérités n Sémantique statique portée, visibilité, typage décompilation transformations au niveau du source

15 Transparent 14 Compilation et Théories n Référence de langages Définition formelle non ambiguë Systèmes générateurs Expressions régulières Grammaires n Reconnaissance des programmes Déterminisme Performance (complexité) Classes de langages Automates finis Automates à pile Langages hors contexte n Sémantique Spécifications exécutables & Générateurs Optimisation Langages à contexte Graphes Systèmes logiques

16 Transparent 15 Métacompilation « compiler-compiler » C O M P I L A T E U R L -> Grammaire lexicale de L Lexical Grammaire syntaxique de L Parser Trans lator Définitions & actions sémantiques L -> GENERATORGENERATOR

17 Transparent 16 Cible Archicture des compilateurs: Evolution et autres applications n Documents XML, DOM, XSLT n Communication par une API intermédiaire Compilateur Partie Avant Source Cible Compilateur Partie Arrière Cible Transformations Cible Edition Décompilation

18 17 Chapitre 2 Analyse lexicale n 2.1 les bases théoriques de limplémentation n 2.2 lex: un méta_générateur lexical n 2.3 lex: des exemples de base

19 Transparent 18 Use P_liste; -- lexicalement correct function ¨ + ¨ (L: out Liste) return Boolean is Aux: Liste := 0 ; begin return 1+ Card(cdr(L)) end Cardinal ; < id,11> < id,13> < id,14> < id, 14> #11: P_liste Analyse lexicale : le découpage dun source Ada

20 Transparent 19 < id,13> < if> < id,1> #11: Pile Analyse lexicale : le découpage dun source Java class Pile { // lexicalement correct public int hauteur () { if vide() return 0; return 1+ this.depile().hauteur() } < id,2> < id,13> < id,11>

21 20 Section 2.1 les bases théoriques de limplémentation Expressions régulières Grammaires régulières Langages rationnels Automates finis Déterminisme

22 Transparent 21 Analyse lexicale : les outils de l implémentation n 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 n 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

23 Transparent 22 Langages Rationnels (Réguliers) n Grammaires régulières (linéaires) n Expressions étendues(lex) n Expressions régulières n Automates finis indéterministes n Automates finis déterministes

24 Transparent 23 n Source format général exemple /*expactions */ a; ekak; abb; a*b+; n AFND n AFD Implémentation des Générateurs d'Analyse Lexicale 2 a 1 0 b 4 a 3 6 b 5 b 8 b 7 a 0137 b 247 a 68 b 58 b 8 b 7 a a b b

25 24 Section 2.2 lex: un méta-générateur lexical

26 Transparent 25 lex : un générateur lexical Analyseur (N)D Table Transitions AF(N)D n lex est un méta-compilateur pour grammaires lexicales [ section de définitions ] % [ section des règles: ExpReg Actions ] [ % code de l utilisateur ] n Sorties analyseur lexical en C: lex.yy.c une fonction de découpage: yylex() n Utilisation sous unix lex source.lexlex.yy.ca.out cc

27 Transparent 26 Définition des Expressions régulières n Alphabets: codes ISO, ASCII, etc n 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) n 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: "/ /"

28 Transparent 27 Les caractères de lex n 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 \ n Les caractères spéciaux (méta-)

29 Transparent 28 Méta-langage et syntaxe de Lex /* 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 */ Définitions lex /* optionnelles */ /* à 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*/

30 Transparent 29 Exécution (simplifiée) d'un analyseur 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; } CCCCCCCCCCCCCCCCCCCCC E1 -> A1 CDCC Lexème le + long possible

31 Transparent 30 Format (non convivial!) de Lex n Espaces ou tabulations ni en début de ligne, ni dans les expressions obligatoire entre expressions et actions n commentaires dans les blocs {} seulement en fin de ligne dans les Règles n Substitution des { } attention aux priorités après substitution n Passage à la ligne impossible sauf | pour "factoriser" des règles n Erreurs classiques exp; [public|private] ["class"] [^"class"] ALPHA ( {L}|{C} ) ID {L} ( {ALPHA} ) *

32 Transparent 31 Lex: variables, fonctions et macros n Analyseur lexical yylex() – la fonction danalyse yywrap() – après l'analyse du texte en entrée n Le « token » en cours char *yytext int yyleng n Etats ou contexte gauche %START %s %x BEGIN

33 Transparent 32 Lex: modifier le fonctionnement n 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 n 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 dentrée ECHO – écrit le token courant

34 Transparent 33 Lex & flex: compléments (1) n Sur les Etats INITIAL ou 0 – tous les états, y compris 0 – «start conditions» multiples { Exp1 R1 ; Expn Rn ; } – règles multiples YY_START – létat courant YYSTATE n 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 n > > – règle spéciale sur fin de fichier yyterminate() – fin danalyse yyin=fopen(*fliste, «r») – chang. de fichier

35 Transparent 34 Exécution d'un analyseur Lex CCCCCCCCCCCCCCCCCCCCC E1 -> A1 CDCC Lexème le + long possible "désarmées" état invalide état valide REJECT yyless() yymore() yyterminate() BEGIN yy_pop_ yy_top_ yy_push_ YY_USER_

36 Transparent 35 Lex & flex: compléments (2) n échappements caractères \176 // le caractère ~ en Octal \x7E // le caractère ~ en Hexa n 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 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]

37 Transparent 36 Lex & flex: compléments (3) n La ligne courante %option yylineno – gestion de la ligne courante n Sur les règles de lanalyseur yy_act – le numéro de la règle activée YY_NUM_RULES – le nombre total de règles n Routines Utilisateur YY_USER_INIT – à faire avant lanalyse YY_USER_ACTION -- à faire à chaque règle n Fichiers *yyin – FILE en entrée *yyout – FILE en sortie yyrestart (FILE *new_file) – FILE

38 Transparent 37 Compléments FLEX pour les Buffers multiples n YY_BUFFER_STATE n YY_CURRENT_BUFFER n yy_create_buffer() YY_BUFFER_STATE yy_create_buffer ( FILE *f, int size) n yy_switch_to_buffer() void yy_switch_to_buffer ( YY_BUFFER_STATE new_buffer ) n yy_delete_buffer() void yy_delete_buffer ( YY_BUFFER_STATE buffer ) n yy_flush_buffer() void yy_flush_buffer ( YY_BUFFER_STATE buffer )

39 38 Section 2.3 Lex: des exemples de base Identificateurs, mots clés, commentaires, chaînes de caractères, des L.P.

40 Transparent 39 lex : les identificateurs Ada n Expression étendue: [a-zA-Z](_?[a-zA-Z0-9])* n Source lex /* définitions lex*/ LET[a-zA-Z] CHIF[0-9] ALPNUM ({LET}|{CHIF}) % /* règle sans action*/ {LET}(_?{ALPNUM})*; %

41 Transparent 40 lex : les identificateurs Java n Expression étendue: [a-zA-Z_$ ] [a-zA-Z0-9_$] * n Source lex /* définitions */ LET [a-zA-Z_$] CHIF [0-9] ALPNUM ({LET}|{CHIF}) % /* règle sans action*/ {LET}({ALPNUM}) * ; %

42 Transparent 41 lex : les chaînes de caractères en Ada n 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 " n Expression correcte % /* règle sans action*/ \" ( [^ " \n ] | \" \" ) \" ; %

43 Transparent 42 lex : les chaînes de caractères en C et Java n 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 " n Expression correcte % /* règle sans action*/ %

44 Transparent 43 lex : les chaînes de caractères en C et Java n Expression ambiguë: ". " => accepte tous les caractères sur une ligne, y compris donc plusieurs " avant le " le plus à droite => ambiguïté: " chaine1 " ++ " chaine2 " ++ " chaine3 " n Expression presque correcte % /* règle sans action*/ \" ( [ ^" ] | \ \ \" ) \" ; % n Expression correcte % /* règle sans action*/ \" ( [ ^" \\] | \ \ (.|\n) ) \" ; %

45 Transparent 44 lex : mots clés, entiers, identificateurs C n 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 MC4 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) ;} %

46 Transparent 45 lex : les commentaires en C forme /* */ n Expression ambiguë: " / ". " / " => accepte tous les caractères dans le commentaire, y compris donc plusieurs / avant le / le plus à droite => ambiguïté: / com1 / ++ / com2 / ++ / com3 / n Expression Régulière Lex n Source lex (avec un état exclusif) %x COM % ? ?

47 Transparent 46 lex : les commentaires en C forme /* */ n Expression ambiguë: " / ". " / " => accepte tous les caractères dans le commentaire, y compris donc plusieurs / avant le / le plus à droite => ambiguïté: / com1 / ++ / com2 / ++ / com3 / n Expression Régulière Lex " / " ( [^ ] | (" ")+ [^/ ] ) (" ")+ " / " n Source lex (avec un état exclusif) %x COM % " / " {BEGIN COM;} " / " {BEGIN 0;}.| \n ; ? ?

48 Transparent 47 lex : les commentaires en C forme /* */ n Expression ambiguë: " / ". " / " => accepte tous les caractères dans le commentaire, y compris donc plusieurs / avant le / le plus à droite => ambiguïté: / com1 / ++ / com2 / ++ / com3 / n Expression correcte n Source lex(avec un état inclusif) %s COM % ? ? ?

49 Transparent 48 lex : les commentaires en C forme /* */ n Expression ambiguë: " / ". " / " => accepte tous les caractères dans le commentaire, y compris donc plusieurs / avant le / le plus à droite => ambiguïté: / com1 / ++ / com2 / ++ / com3 / n Expression correcte " / " ( [^ ] | (" ")+ [^/ ] ) (" ")+ " / " n Source lex(avec un état inclusif) %s COM % " / " {BEGIN COM;} " / " {BEGIN 0;}.| \n ; ? ? ?

50 Transparent 49 Unités lexicales imbriquées en lex n 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. n Reconnus ou pas ? MCif | else | do | while | for | case | switch %s COM /* ou %x ? */ % {MC}{printf( "mclé: %s\n", yytext) ;} % ?

51 Transparent 50 Unités lexicales imbriquées en lex n 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. n Reconnus ou pas ? MCif | else | do | while | for | case | switch %s COM /* ou %x ? */ % {MC}{printf( "mclé: %s\n", yytext) ;} "/*" {BEGIN COM; ECHO;}.|\nECHO; "*/" {BEGIN 0; ECHO;} % ?

52 Transparent 51 lex : supprimer les espaces sauf dans les chaînes (1) n Avec un état exclusif %x CHA % Attention: les règles 2, 3 et 4 ne sont activables que dans l'état dans l'état, 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 hors de l'état, " " est reconnu par la règle 5 et non pas 6 ? ?

53 Transparent 52 lex : supprimer les espaces sauf dans les chaînes (1) n Avec un état exclusif %x CHA % \" {ECHO; BEGIN CHA;} " " ECHO; \" {ECHO; BEGIN 0;} \\\" ECHO; " " ;. | \n ECHO; Attention: les règles 2, 3 et 4 ne sont activables que dans l'état dans l'état, 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 hors de l'état, " " est reconnu par la règle 5 et non pas 6 ? ?

54 Transparent 53 lex : supprimer les espaces sauf dans les chaînes (2) n Avec un état inclusif %s CHA % Attention: la règle 1 n'est activable que dans l'état les règles 2, 3 et 4 ne sont activables que dans l'état dans l'état, 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 et par la régle 5 sinon ?

55 Transparent 54 lex : supprimer les espaces sauf dans les chaînes (2) n Avec un état inclusif %s CHA % \" {ECHO; BEGIN CHA;} " " ECHO; \" {ECHO; BEGIN 0;} \\\" ECHO; " " ;. | \n ECHO; Attention: la règle 1 n'est activable que dans l'état les règles 2, 3 et 4 ne sont activables que dans l'état dans l'état, 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 et par la régle 5 sinon ? ?

56 Transparent 55 lex : compter les éléments dun texte n 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); }

57 56 Section 2.4 Traitement lexical des Textes par Expressions régulières awk, grep, find, emacs, etc. Java Python Perl JavaScript

58 Transparent 57 Expressions grep -E -P

59 Transparent 58 Java Le Paquetage Java.util.regex n Expressions régulières String expreg n java.util.regex.Pattern Pattern p = Pattern.compile(expreg) n java.util.regex.Matcher Matcher m = p.matcher( ) m.find() m.group()

60 Transparent 59 Python Le Module re n expreg = re.compile(' … ') n m = expreg.match(… ) n if m n m.group( …)

61 Transparent 60 Expressions Perl (1)

62 Transparent 61 Expressions Perl (2) n 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/

63 Transparent 62 JavaScript 1.5 et + (ECMAScript) Les expressions (Ecmascript v3, Perl 5 ) n la classe RegExp var motif=/finADroite$/i; var motif=new RegExp("finADroite$", i); n méthodes match() substr() replace() split() n Modes i (ignorer la casse) g (global, donc toutes les occurrences) n Répétition non avide (not "greedy") ?? +? *? n Groupe seulement (non numéroté) (? :

64 63 Un modèle d'architecture partie avant partie arrière


Télécharger ppt "1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés."

Présentations similaires


Annonces Google