1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de...
-
Upload
oriane-joubert -
Category
Documents
-
view
113 -
download
3
Transcript of 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de...
![Page 1: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/1.jpg)
1
Langages et Documents
Traitements des textes « sources »
Langages et Documents
Traitements des textes « sources »
Paul FranchiSI - 4
2013-14
Langages de Programmation
Documents Structurés
Langages de Programmation
Documents Structurés
![Page 2: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/2.jpg)
Transparent 3
Quelques dates 1957-68 Fortran, Cobol, Lisp, Algol, APL, PL/I,
Basic 1968 Pascal, Simula, Algol 68 1969 Multics Unix 1972 B C, Prolog, Lex, Yacc 1974 DOS, TeX 1975 Scheme 1979-83 Green (DoD) => Ada 1980 Smalltalk, Modula 2 1981 MS-DOS 1982 PostScript, LaTeX 1984 Lisa => Mac & Souris 1985 Windows 1983-86 C++ 1987 Perl, SQL 1989 ANSI C, Modula 3 1990 Mosaic + HTML 1991 Unix Linux, Python 1993 PDF 1995 Java, Windows 1995- AltaVista, MSN, Yahoo, etc. 1996 SGML XML, JavaScript 2004 iTunes, iPod 2008 Google = 100 Gigas$ 2010 iPod x 275 Millions 2010 Apple = 225 Giga$ > Microsoft
![Page 3: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/3.jpg)
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
![Page 4: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/4.jpg)
5
Compilation Analyses Lexicale, Syntaxique, et Sémantique
Compilation Analyses Lexicale, Syntaxique, et Sémantique
Paul FranchiSI deuxième année
2013-14
Chapitres 1 & 2Chapitres 1 & 2
![Page 5: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/5.jpg)
Transparent 6
Sommaire
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»
![Page 6: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/6.jpg)
7
Chapitre 1Introduction à la Compilation
Historique Schéma conceptuel Phases et passes Structures et langages intermédiaires Méta-compilation
![Page 7: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/7.jpg)
Transparent 8
CompilateurPartie Partie
Avant Arrière
Source
Messages d’erreurs
Cible
Conception: modèle Analyse et Synthèse
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
![Page 8: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/8.jpg)
Transparent 9
A. lexicale
Source
Cible
Phases & Passes 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)
A. syntaxique
A. sémantique
G. code intermédiaire
Optimiseur de code
G. de code
S
y
m
b
o
l
e
s
E
r
r
e
u
r
s
![Page 9: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/9.jpg)
Transparent 10
Table
Symbôles.
Anal. Lex Anal. Synt.
LexèmesSource
Identificateurs
Arbres
requête
Phase lexicale : fonctionnalités
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.
Source
instrumenté.
![Page 10: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/10.jpg)
Transparent 11
Phase lexicale : pourquoi la séparer de la phase syntaxique ?
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
![Page 11: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/11.jpg)
Transparent 12
Phase syntaxique
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 une seule passe de gauche à droite construction de l’arbre en montant à partir
des feuilles meilleure complexité : O(|source|)
![Page 12: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/12.jpg)
Transparent 13
Phase sémantique statique
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
![Page 13: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/13.jpg)
Transparent 14
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 finisAutomates à pileLangages hors
contexte
Sémantique Spécifications exécutables & Générateurs Optimisation
Langages à contexteGraphesSystèmes logiques
![Page 14: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/14.jpg)
Transparent 15
Métacompilation« compiler-compiler »
COMPILATEUR
L ->
Grammaire
lexicale
de LLexical
Grammaire
syntaxique
de LParser
Trans
lator
Définitions
& actions
sémantiques
L ->
G
E
N
E
R
A
T
O
R
![Page 15: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/15.jpg)
Transparent 16
Cible
Archicture des compilateurs:Evolution et autres applications
Documents XML, DOM, XSLT
Communication par une API intermédiaire
CompilateurPartie Avant
Source
Cible
CompilateurPartie Arrière
Cible
Transformations
Cible
Edition
Décompilation
![Page 16: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/16.jpg)
17
Chapitre 2Analyse 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
![Page 17: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/17.jpg)
Transparent 19
<public> <int> < id,13> <(> <)> <{>
< if> < id,1> <(> <)> <return> <ce,0> <:>
<return> <ce,1> <op,+> <this> <.>
#11:
Pile
Analyse lexicale : le découpage d’un source Java
class Pile {// lexicalement correctpublic int hauteur () {
if vide() return 0;return 1+ this.depile().hauteur()
}
}
< id,2> <(> <)> <.> < id,13> <(> <)> <}> <}>
<class> < id,11> <{>
![Page 18: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/18.jpg)
20
Section 2.1les bases théoriques de l’implémentation
Expressions régulières
Grammaires régulières
Langages rationnels
Automates finis
Déterminisme
![Page 19: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/19.jpg)
Transparent 21
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
![Page 20: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/20.jpg)
Transparent 22
Langages Rationnels (Réguliers)
Grammaires régulières (linéaires)
Expressions étendues(lex)
Expressions régulières
Automates finis indéterministes
Automates finis déterministes
![Page 21: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/21.jpg)
Transparent 23
Source format général exemple
/*exp actions */a
;ek ak; abb
;a*b+
; AFND
AFD
Implémentation des Générateurs d'Analyse Lexicale
2a
1
0
b
4a
3 6b
5b
8b
7
a
0137
b
247a
68b
58b
8b
7
a
ab
b
![Page 22: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/22.jpg)
24
Section 2.2lex: un méta-générateur lexical
![Page 23: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/23.jpg)
Transparent 25
lex : un générateur lexical
Analyseur
(N)D
Table
Transitions
AF(N)D
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
lexsource.lex lex.yy.c a.out
cc
![Page 24: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/24.jpg)
Transparent 26
Définition des Expressions régulières
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: "/ /"
![Page 25: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/25.jpg)
Transparent 27
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-)
Forme de Kleene e? 0 ou 1 fois l’exp e e* 0 ou n fois l’exp e e+ 1 ou n fois l’exp e e f l'exp e f e | f l'exp e ou l'exp f
e{n,m} l'exp e répétée entre n et m fois (e) l'exp e {D} l'exp obtenue par substitution de D
Contexte sensitivité e / f l'exp e si suivie de l'exp f ^e exp e en début de ligne e$ exp e en fin de ligne
<E>e L'exp e si dans l'état E Caractères
. tout caractère sauf \n \c le caractère c , même spécial
"abc" la chaine de caractères abc [abc] le caractère a ou b ou c [^abc] un des caractères sauf a, b, c [a-c] le caractère a ou b ou c
![Page 26: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/26.jpg)
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*/
![Page 27: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/27.jpg)
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
CD CC
Lexème le + long possible
![Page 28: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/28.jpg)
Transparent 30
Format (non convivial!) de Lex
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} ) *
![Page 29: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/29.jpg)
Transparent 31
Lex: variables, fonctions et macros
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
![Page 30: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/30.jpg)
Transparent 32
Lex: modifier le fonctionnement
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
![Page 31: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/31.jpg)
Transparent 33
Lex & flex: compléments (1)
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
![Page 32: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/32.jpg)
Transparent 34
Exécution d'un analyseur Lex
CCCCCCCCCCCCCCCCCCCCC
E1 -> A1
CD CC
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_
![Page 33: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/33.jpg)
Transparent 35
Lex & flex: compléments (2)
é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]
![Page 34: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/34.jpg)
Transparent 36
Lex & flex: compléments (3)
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
![Page 35: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/35.jpg)
38
Section 2.3Lex: des exemples de base
Identificateurs, mots clés,
commentaires, chaînes de caractères,
des L.P.
![Page 36: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/36.jpg)
Transparent 39
lex : les identificateurs Ada
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})* ;
%%
![Page 37: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/37.jpg)
Transparent 40
lex : les identificateurs Java
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}) * ;
%%
![Page 38: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/38.jpg)
Transparent 41
lex : les chaînes de caractères en Ada
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 ] | \" \" ) \" ;
%%
![Page 39: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/39.jpg)
Transparent 42
lex : les chaînes de caractères en C et Java
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*/
%%
![Page 40: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/40.jpg)
Transparent 44
lex :mots clés, entiers, identificateurs C
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) ;}
%%
![Page 41: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/41.jpg)
Transparent 45
lex : les commentaires en C forme /* */
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%%
? ?
![Page 42: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/42.jpg)
Transparent 47
lex : les commentaires en C forme /* */
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%%
?
?
?
![Page 43: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/43.jpg)
Transparent 49
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) ;}
%%
?
![Page 44: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/44.jpg)
Transparent 51
lex : supprimer les espaces sauf dans les chaînes (1)
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
?
?
![Page 45: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/45.jpg)
Transparent 53
lex : supprimer les espaces sauf dans les chaînes (2)
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
?
![Page 46: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/46.jpg)
Transparent 55
lex : compter les éléments d’un texte
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);
}
![Page 47: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/47.jpg)
56
Section 2.4Traitement lexical des Textes par Expressions régulières
awk, grep, find, emacs, etc.
Java
Python
Perl
JavaScript
![Page 48: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/48.jpg)
Transparent 57
Expressions grep -E -P
e? 0 ou 1 fois l’exp e e* 0 ou n fois l’exp e e+ 1 ou n fois l’exp e e f l'exp e f e | f l'exp e ou l'exp f e{n} l'exp e répétée n fois
e{n,m} l'exp e répétée entre n et m fois e{n,} l'exp e répétée n fois ou plus (e) l'exp e ou le groupe e ^e exp e en début de ligne, e$ exp e en fin de ligne. \<e exp e en début de mot e\> exp e en fin de mot
. tout caractère sauf \n \c le caractère c , même spécial
"abc" la chaine abc [abc] le caractère a ou b ou c [^abc] un des caractères sauf a, b, c [a-c] le caractère a ou b ou c
\i répéter le ième groupe( ) reconnu
![Page 49: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/49.jpg)
Transparent 58
Java
Le Paquetage Java.util.regex
Expressions régulièresString expreg
java.util.regex.PatternPattern p = Pattern.compile(expreg)
java.util.regex.MatcherMatcher m = p.matcher( )m.find()m.group()
![Page 50: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/50.jpg)
Transparent 59
Python
Le Module re
expreg = re.compile(' … ')
m = expreg .match(… )
if m
m.group( …)
![Page 51: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/51.jpg)
Transparent 60
Expressions Perl (1)
e? 0 ou 1 fois l’exp e e* 0 ou n fois l’exp e e+ 1 ou n fois l’exp e e f l'exp e f e | f l'exp e ou l'exp f e{n} l'exp e répétée n fois
e{n,m} l'exp e répétée entre n et m fois e{n,} l'exp e répétée n fois ou plus (e) l'exp e ou le groupe e ^e exp e en début de ligne, e$ exp e en fin de ligne. \Ae exp e en début de mot e\Z exp e en fin de mot
. tout caractère sauf \n \c le caractère c , même spécial
"abc" la chaine de caractères abc [abc] le caractère a ou b ou c [^abc] un des caractères sauf a, b, c \d \D caractère chiffre ou non
\w \W caractère alphanum ou non [a-c] le caractère a ou b ou c \i $i le ième groupe( ) reconnu
![Page 52: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/52.jpg)
Transparent 61
Expressions Perl (2)
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/
![Page 53: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/53.jpg)
Transparent 62
JavaScript 1.5 et + (ECMAScript)
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é) (? :
![Page 54: 1 Langages et Documents Traitements des textes « sources » Paul Franchi SI - 4 2013-14 Langages de Programmation Documents Structurés.](https://reader035.fdocuments.us/reader035/viewer/2022062307/551d9d81497959293b8bb2e8/html5/thumbnails/54.jpg)
63
Un modèle d'architecture
partie avant partie arrière