diff --git a/dependencies/pandoc.css b/dependencies/pandoc.css
new file mode 100644
index 0000000..8b9903f
--- /dev/null
+++ b/dependencies/pandoc.css
@@ -0,0 +1,328 @@
+/*
+ * I add this to html files generated with pandoc.
+ */
+
+html {
+ font-size: 100%;
+ overflow-y: scroll;
+ -webkit-text-size-adjust: 100%;
+ -ms-text-size-adjust: 100%;
+}
+
+body {
+ color: #444;
+ font-family: Georgia, Palatino, 'Palatino Linotype', Times, 'Times New Roman', serif;
+ font-size: 12px;
+ line-height: 1.7;
+ padding: 1em;
+ margin: auto;
+ max-width: 42em;
+ background: #fefefe;
+}
+
+a {
+ color: #0645ad;
+ text-decoration: none;
+}
+
+a:visited {
+ color: #0b0080;
+}
+
+a:hover {
+ color: #06e;
+}
+
+a:active {
+ color: #faa700;
+}
+
+a:focus {
+ outline: thin dotted;
+}
+
+*::-moz-selection {
+ background: rgba(255, 255, 0, 0.3);
+ color: #000;
+}
+
+*::selection {
+ background: rgba(255, 255, 0, 0.3);
+ color: #000;
+}
+
+a::-moz-selection {
+ background: rgba(255, 255, 0, 0.3);
+ color: #0645ad;
+}
+
+a::selection {
+ background: rgba(255, 255, 0, 0.3);
+ color: #0645ad;
+}
+
+p {
+ margin: 1em 0;
+}
+
+img {
+ max-width: 100%;
+}
+
+h1, h2, h3, h4, h5, h6 {
+ color: #111;
+ line-height: 125%;
+ margin-top: 2em;
+ font-weight: normal;
+}
+
+h4, h5, h6 {
+ font-weight: bold;
+}
+
+h1 {
+ font-size: 2.5em;
+}
+
+h2 {
+ font-size: 2em;
+}
+
+h3 {
+ font-size: 1.5em;
+}
+
+h4 {
+ font-size: 1.2em;
+}
+
+h5 {
+ font-size: 1em;
+}
+
+h6 {
+ font-size: 0.9em;
+}
+
+blockquote {
+ color: #666666;
+ margin: 0;
+ padding-left: 3em;
+ border-left: 0.5em #EEE solid;
+}
+
+hr {
+ display: block;
+ height: 2px;
+ border: 0;
+ border-top: 1px solid #aaa;
+ border-bottom: 1px solid #eee;
+ margin: 1em 0;
+ padding: 0;
+}
+
+pre, code, kbd, samp {
+ color: #000;
+ font-family: monospace, monospace;
+ _font-family: 'courier new', monospace;
+ font-size: 0.98em;
+}
+
+pre {
+ white-space: pre;
+ white-space: pre-wrap;
+ word-wrap: break-word;
+}
+
+b, strong {
+ font-weight: bold;
+}
+
+dfn {
+ font-style: italic;
+}
+
+ins {
+ background: #ff9;
+ color: #000;
+ text-decoration: none;
+}
+
+mark {
+ background: #ff0;
+ color: #000;
+ font-style: italic;
+ font-weight: bold;
+}
+
+sub, sup {
+ font-size: 75%;
+ line-height: 0;
+ position: relative;
+ vertical-align: baseline;
+}
+
+sup {
+ top: -0.5em;
+}
+
+sub {
+ bottom: -0.25em;
+}
+
+ul, ol {
+ margin: 1em 0;
+ padding: 0 0 0 2em;
+}
+
+li p:last-child {
+ margin-bottom: 0;
+}
+
+ul ul, ol ol {
+ margin: .3em 0;
+}
+
+dl {
+ margin-bottom: 1em;
+}
+
+dt {
+ font-weight: bold;
+ margin-bottom: .8em;
+}
+
+dd {
+ margin: 0 0 .8em 2em;
+}
+
+dd:last-child {
+ margin-bottom: 0;
+}
+
+img {
+ border: 0;
+ -ms-interpolation-mode: bicubic;
+ vertical-align: middle;
+}
+
+figure {
+ display: block;
+ text-align: center;
+ margin: 1em 0;
+}
+
+figure img {
+ border: none;
+ margin: 0 auto;
+}
+
+figcaption {
+ font-size: 0.8em;
+ font-style: italic;
+ margin: 0 0 .8em;
+}
+
+table {
+ margin-bottom: 2em;
+ border-bottom: 1px solid #ddd;
+ border-right: 1px solid #ddd;
+ border-spacing: 0;
+ border-collapse: collapse;
+}
+
+table th {
+ padding: .2em 1em;
+ background-color: #eee;
+ border-top: 1px solid #ddd;
+ border-left: 1px solid #ddd;
+}
+
+table td {
+ padding: .2em 1em;
+ border-top: 1px solid #ddd;
+ border-left: 1px solid #ddd;
+ vertical-align: top;
+}
+
+.author {
+ font-size: 1.2em;
+ text-align: center;
+}
+
+@media only screen and (min-width: 480px) {
+ body {
+ font-size: 14px;
+ }
+}
+@media only screen and (min-width: 768px) {
+ body {
+ font-size: 16px;
+ }
+}
+@media print {
+ * {
+ background: transparent !important;
+ color: black !important;
+ filter: none !important;
+ -ms-filter: none !important;
+ }
+
+ body {
+ font-size: 12pt;
+ max-width: 100%;
+ }
+
+ a, a:visited {
+ text-decoration: underline;
+ }
+
+ hr {
+ height: 1px;
+ border: 0;
+ border-bottom: 1px solid black;
+ }
+
+ a[href]:after {
+ content: " (" attr(href) ")";
+ }
+
+ abbr[title]:after {
+ content: " (" attr(title) ")";
+ }
+
+ .ir a:after, a[href^="javascript:"]:after, a[href^="#"]:after {
+ content: "";
+ }
+
+ pre, blockquote {
+ border: 1px solid #999;
+ padding-right: 1em;
+ page-break-inside: avoid;
+ }
+
+ tr, img {
+ page-break-inside: avoid;
+ }
+
+ img {
+ max-width: 100% !important;
+ }
+
+ @page :left {
+ margin: 15mm 20mm 15mm 10mm;
+}
+
+ @page :right {
+ margin: 15mm 10mm 15mm 20mm;
+}
+
+ p, h2, h3 {
+ orphans: 3;
+ widows: 3;
+ }
+
+ h2, h3 {
+ page-break-after: avoid;
+ }
+}
diff --git a/theoriedeslangagesetcompilation/README.md b/theoriedeslangagesetcompilation/README.md
index 9c9c469..ed397a8 100644
--- a/theoriedeslangagesetcompilation/README.md
+++ b/theoriedeslangagesetcompilation/README.md
@@ -3,8 +3,8 @@ Théorie des langages de programmation & compilation
#### Cours
-1. [Introduction](/cours/introduction.md)
-1. [Chapitre 1](/cours/1.md)
+1. [Introduction](/cours/compiled/introduction.html)
+2. [Chapitre 1](/cours/compiled/1.html)
#### TDs
diff --git a/theoriedeslangagesetcompilation/compile b/theoriedeslangagesetcompilation/compile
new file mode 100755
index 0000000..0ad9f76
--- /dev/null
+++ b/theoriedeslangagesetcompilation/compile
@@ -0,0 +1,3 @@
+#!/bin/sh
+
+pandoc -f markdown -t html5 --css ../../../dependencies/pandoc.css introduction.md -o compiled/introduction.html
diff --git a/theoriedeslangagesetcompilation/cours/1.md b/theoriedeslangagesetcompilation/cours/1.md
index 1392047..22600f8 100644
--- a/theoriedeslangagesetcompilation/cours/1.md
+++ b/theoriedeslangagesetcompilation/cours/1.md
@@ -4,44 +4,49 @@ Chapitre I - Langages
### Définition d'un langage
-> Un langage est un ensemble de mots qui peut être défini :
-> - En extension: liste exhaustive de tous les mots du langage (ex: dictionnaire)
-> - En compréhension: on commence une énumération (L={`ab`, `aabb`, `aaabbb`, ...})
-> - En intension: on se donne des règles. Exemple: tous les mots formés de `a` et `b` qui comportent autant d'occurences de `a` que de `b` et dont tous les `a` sont en première positions.
-> - Inductivement: outils de définitions compacts de langages
+Un langage est un ensemble de mots qui peut être défini :
+
+* En extension: liste exhaustive de tous les mots du langage (ex: dictionnaire)
+* En compréhension: on commence une énumération ($L=\{ab, aabb, aaabbb, ...\}$)
+* En intension: on se donne des règles. Exemple: tous les mots formés de $a$ et $b$ qui comportent autant d'occurences de $a$ que de $b$ et dont tous les $a$ sont en première positions.
+* Inductivement: outils de définitions compacts de langages
##### L'ambiguité
-`Une phrase ambigue`
+**Une phrase ambigue**
+
> phrase à laquelle on peut attribuer plusieurs sens (en informatique, on parle de _conflit_).
-`Une interprétation d'une phrase ambigue`
-> sens que l'on attribue à cette phrase. (exemple: `2+3\*4` peut se calculer différemment en fonction des règles de calcul)
+
+**Une interprétation d'une phrase ambigue**
+
+> sens que l'on attribue à cette phrase. (exemple: $2+3\times4$ peut se calculer différemment en fonction des règles de calcul)
### Définitions inductives
Les **définitions inductives** (recursive definitions)
+**idée**: on procède en 3 étapes
-idée: on procède en 3 étapes
-1. On se donne une **base** d'objets appartenant à l'ensemble que l'on veut définir
-2. On se donne des **règles** pour construire d'autres objets de l'ensemble à partir d'objets de la base ou d'objets déjà construits.
+1. On se donne une **base** d'objets appartenant à l'ensemble que l'on veut définir
+2. On se donne des **règles** pour construire d'autres objets de l'ensemble à partir d'objets de la base ou d'objets déjà construits.
3. On déclare que les seuls objets de l'ensemble sont ceux construits en **appliquant** un nombre **fini** de fois des règles.
-On n'exige pas que la base soit minimale
+_On n'exige pas que la base soit minimale_
-Souvent on donne une définition inductive sous la forme `base + règles`
+_Souvent on donne une définition inductive sous la forme $base + règles$_
-Exemple: Définissons l'ensemble `PAIR` des entiers pairs positifs:
-1. Base: 2 appartien à `PAIR`
-2. Règle: Si `x` est dans `PAIR`, alors `x+2` est dans `PAIR`
-- Pour montrer qu'un nombre est dans `PAIR`, on exhibera une succession d'application des règles
-- La définition inductive d'un ensemble n'est pas unique
-- exemple 2:
- 1. Base: 2 est dans `PAIR`
- 2. Règle: si `x` et `y` sont dans `PAIR`, alors `x+y` est dans `PAIR`
-- Avantage de l'exemple 2: les preuves qu'un nombre appartient à `PAIR` sont plus courtes.
+**Exemple**: Définissons l'ensemble $PAIR$ des entiers pairs positifs:
+
+1. Base: 2 appartien à $PAIR$
+2. Règle: Si $x$ est dans $PAIR$, alors $x+2$ est dans $PAIR$
+* Pour montrer qu'un nombre est dans $PAIR$, on exhibera une succession d'application des règles
+* La définition inductive d'un ensemble n'est pas unique
+* exemple 2:
+ 1. Base: 2 est dans $PAIR$
+ 2. Règle: si $x$ et $y$ sont dans $PAIR$, alors $x+y$ est dans $PAIR$
+* Avantage de l'exemple 2: les preuves qu'un nombre appartient à $PAIR$ sont plus courtes.
Principe pour décrire les langages par une **grammaire** (procédé formel de construction inductive du langage sous la forme d'un axiome (la base) et d'un ensemble de règles de production.
@@ -52,51 +57,65 @@ Principe pour décrire les langages par une **grammaire** (procédé formel de c
##### Propriétés de l'alphabet
**Définition**
-> Un alphabet `\sigma` est un ensemble **fini** de smyboles.
-> _exemple_: `\sigma = {a, b}`
+
+> Un alphabet $\Sigma$ est un ensemble **fini** de smyboles.
+> _exemple_: $\Sigma = \{a, b\}$
+
##### Propriétés du mot
**Définition**
-> Un **mot** (appelé aussi chaine) `X` sur `\sigma` est une suite finie de symboles de `\sigma` juxtaposés.
-**Longueur**
+> Un **mot** (appelé aussi chaine) $X$ sur $\Sigma$ est une suite finie de symboles de $\Sigma$ juxtaposés.
+
+**Longueur**
+
> Nombre de symboles de l'alphabet composant le mot.
-> - notée `|X|`
-> - `|x|_a` dénote le nombre d'occurences de la lettre `a` dans le mot `X`
-> - _exemple_: `\sigma = {a, b}, X = aabbaa` est un mot sur `\sigma`; `|X| = 5`, et `|X|_a = 4`
+
+> * notée $|X|$
+> * $|X|_a$ dénote le nombre d'occurences de la lettre $a$ dans le mot $X$
+> * _exemple_: $\Sigma = \{a, b\},\ X = aabbaa$ est un mot sur $\Sigma$; $|X| = 5$, et $|X|_a = 4$
**mot vide**
-> Le **mot vide** ne contenant aucun symbole est noté `\epsilon`, `|\epsilon| = 0`
-> - `\epsilon` peut être un mot d'un langage, mais n'est pas une lettre de l'alphabet
+
+> Le **mot vide** ne contenant aucun symbole est noté $\epsilon$, $|\epsilon| = 0$
+> - $\epsilon$ peut être un mot d'un langage, mais n'est pas une lettre de l'alphabet
##### Opérations du mot
**Concaténation**
-> Concaténation: soit `X` et `Y` deux mots de `\sigma`. On appelle **concaténation** de `X` et de `Y`, le mot `XY`
-> - Notation: `X.Y` ou `XY`
-> - C'est une loi de formation de mots *associative*, *non commutative*, et qui admet `\epsilon` comme *élèment neutre*: `X\epsilon = \epsilonX = X`
-> - Forme condensée de la concaténation (puissance): `X^n = XXXX...` n fois, `X^0 = \epsilon`
+
+> Concaténation: soit $X$ et $Y$ deux mots de $\Sigma$. On appelle **concaténation** de $X$ et de $Y$, le mot $XY$
+
+> - Notation: $X.Y$ ou $XY$
+> - C'est une loi de formation de mots *associative*, *non commutative*, et qui admet $\epsilon$ comme *élèment neutre*: $X \epsilon = \epsilon X = X$
+> - Forme condensée de la concaténation (puissance): $X^n = XXXX...$ n fois, $X^0 = \epsilon$
**Préfixe**
-> Tout mot `f` (mot vide inclus) qui permet d'écrire `X = fg`
+
+> Tout mot $f$ (mot vide inclus) qui permet d'écrire $X = fg$
**Suffixe**
-> Tout mot `g` (mot vide inclus) qui permet d'écrire `X = fg`
-**Préfixe/Suffixe propre**
-> `U` est un préfixe/suffixe propre de `X` **ssi** `U` est préfixe/suffixe de `X` et `U` est différent de `X`
-> - remarque: `X` est préfixe ou suffixe de lui-même
+> Tout mot $g$ (mot vide inclus) qui permet d'écrire $X = fg$
+
+**Préfixe/Suffixe propre**
+
+> $U$ est un préfixe/suffixe propre de $X$ **ssi** $U$ est préfixe/suffixe de $X$ et $U$ est différent de $X$
+> - remarque: $X$ est préfixe ou suffixe de lui-même
**Facteur/sous-mot**
-> Un facteur, ou sous-mot est tout mot `g` qui permet d'écrire `X = fgh`, avec `f` et `h` non vides.
+
+> Un facteur, ou sous-mot est tout mot $g$ qui permet d'écrire $X = fgh$, avec $f$ et $h$ non vides.
**Fermeture de Kleen**
-> Soit `\sigma` un alphabet, on appelle **fermeture de Kleen** de `\sigma`, noté `\sigma*`. L'ensemble est défini inductivement de la façon suivante :
-> - base: tous les symboles de `\sigma` ainsi que le mot vide sont dans `\sigma*`
-> - règle: si `x` et `y` sont dans `\sigma*`, alors `xy` est dans `\sigma*`> \*
-> `\sigma*` est l'ensemble des mots sur `\sigma`, de longueur finie, plus le mot vide:
-> on note `\sigma+ = \sigma* \\ \epsilon`
+
+> Soit $\Sigma$ un alphabet, on appelle **fermeture de Kleen** de $\Sigma$, noté $\Sigma^*$. L'ensemble est défini inductivement de la façon suivante :
+
+> - base: tous les symboles de $\Sigma$ ainsi que le mot vide sont dans $\Sigma^*$
+> - règle: si $x$ et $y$ sont dans $\Sigma^*$, alors $xy$ est dans $\Sigma^*$
+> $\Sigma^*$ est l'ensemble des mots sur $\Sigma$, de longueur finie, plus le mot vide.
+> - on note $\Sigma^+ = \Sigma^* \setminus \epsilon$
### Opérations sur les langages
diff --git a/theoriedeslangagesetcompilation/cours/compiled/1.html b/theoriedeslangagesetcompilation/cours/compiled/1.html
new file mode 100644
index 0000000..18ef6a7
--- /dev/null
+++ b/theoriedeslangagesetcompilation/cours/compiled/1.html
@@ -0,0 +1,131 @@
+
+
+
+
+
+
+
+
+
+
+
+
+
Chapitre I - Langages
+
Définition d'un langage
+
Un langage est un ensemble de mots qui peut être défini :
+
+
En extension: liste exhaustive de tous les mots du langage (ex: dictionnaire)
+
En compréhension: on commence une énumération (L = {ab, aabb, aaabbb, ...})
+
En intension: on se donne des règles. Exemple: tous les mots formés de a et b qui comportent autant d'occurences de a que de b et dont tous les a sont en première positions.
+
Inductivement: outils de définitions compacts de langages
+
+
L'ambiguité
+
Une phrase ambigue
+
+
phrase à laquelle on peut attribuer plusieurs sens (en informatique, on parle de conflit).
+
+
Une interprétation d'une phrase ambigue
+
+
sens que l'on attribue à cette phrase. (exemple: 2 + 3 × 4 peut se calculer différemment en fonction des règles de calcul)
+
+
Définitions inductives
+
Les définitions inductives (recursive definitions)
+
idée: on procède en 3 étapes
+
+
On se donne une base d'objets appartenant à l'ensemble que l'on veut définir
+
+
On se donne des règles pour construire d'autres objets de l'ensemble à partir d'objets de la base ou d'objets déjà construits.
+
+
On déclare que les seuls objets de l'ensemble sont ceux construits en appliquant un nombre fini de fois des règles.
+
+
On n'exige pas que la base soit minimale
+
Souvent on donne une définition inductive sous la forme base + règles
+
Exemple: Définissons l'ensemble PAIR des entiers pairs positifs:
+
+
Base: 2 appartien à PAIR
+
Règle: Si x est dans PAIR, alors x + 2 est dans PAIR
+
+
+
Pour montrer qu'un nombre est dans PAIR, on exhibera une succession d'application des règles
+
La définition inductive d'un ensemble n'est pas unique
+
exemple 2:
+
+
Base: 2 est dans PAIR
+
Règle: si x et y sont dans PAIR, alors x + y est dans PAIR
+
+
Avantage de l'exemple 2: les preuves qu'un nombre appartient à PAIR sont plus courtes.
+
+
Principe pour décrire les langages par une grammaire (procédé formel de construction inductive du langage sous la forme d'un axiome (la base) et d'un ensemble de règles de production.
+
Définitions sur les langages
+
Propriétés de l'alphabet
+
Définition
+
+
Un alphabet Σ est un ensemble fini de smyboles.
+exemple: Σ = {a, b}
+
+
Propriétés du mot
+
Définition
+
+
Un mot (appelé aussi chaine) X sur Σ est une suite finie de symboles de Σ juxtaposés.
+
+
Longueur
+
+
Nombre de symboles de l'alphabet composant le mot.
+
+
+
+
notée |X|
+
|X|a dénote le nombre d'occurences de la lettre a dans le mot X
+
exemple: Σ = {a, b}, X = aabbaa est un mot sur Σ; |X|=5, et |X|a = 4
+
+
+
mot vide
+
+
Le mot vide ne contenant aucun symbole est noté ϵ, |ϵ|=0
+- ϵ peut être un mot d'un langage, mais n'est pas une lettre de l'alphabet
+
+
Opérations du mot
+
Concaténation
+
+
Concaténation: soit X et Y deux mots de Σ. On appelle concaténation de X et de Y, le mot XY
+
+
+
+
Notation: X.Y ou XY
+
C'est une loi de formation de mots associative, non commutative, et qui admet ϵ comme élèment neutre: Xϵ = ϵX = X
+
Forme condensée de la concaténation (puissance): Xn = XXXX... n fois, X0 = ϵ
+
+
+
Préfixe
+
+
Tout mot f (mot vide inclus) qui permet d'écrire X = fg
+
+
Suffixe
+
+
Tout mot g (mot vide inclus) qui permet d'écrire X = fg
+
+
Préfixe/Suffixe propre
+
+
U est un préfixe/suffixe propre de XssiU est préfixe/suffixe de X et U est différent de X - remarque: X est préfixe ou suffixe de lui-même
+
+
Facteur/sous-mot
+
+
Un facteur, ou sous-mot est tout mot g qui permet d'écrire X = fgh, avec f et h non vides.
+
+
Fermeture de Kleen
+
+
Soit Σ un alphabet, on appelle fermeture de Kleen de Σ, noté Σ*. L'ensemble est défini inductivement de la façon suivante :
+
+
+
+
base: tous les symboles de Σ ainsi que le mot vide sont dans Σ*
+
règle: si x et y sont dans Σ*, alors xy est dans Σ*
+Σ* est l'ensemble des mots sur Σ, de longueur finie, plus le mot vide.
créé par les linguistes pour décrire les langages naturels
+
+
effectuer des traductions automatiques
+
+
Noam CHOMSKY: modèle mathématique pour les grammaires
+
+
1958: langage ALGOL décrit à l'aide d'une grammaire "Hors-Contexte" (notations BNF: description d'un langage de prog.)
+
+
+
Pourquoi étudier les langages formels ? - conception de langages: syntaxe et grammaire - Analyse - lexicale: déterminer les entités syntaxiques) - syntaxicale: vérifier la syntaxe - compilation: traduction - Générateurs d'analyseurs lexicaux (ex: lex) - Méta-compilateurs : compilateurs de compilateurs, ou générateurs de compilateur (ex: compilateur Ada compilé avec gcc) - Nécessaire pour l'étude des langages de programmation
+
Un compilateur ?
+
PROGRAMME SOURCE
+ |
+ V
+ COMPILATEUR -> messages d'erreur
+ |
+ V
+ PROGRAMME CIBLE
+
Un compilateur est un programme qui
+
+
prend en entrée une donnée textuelle source (programme, donnée xml, fichier de configuration, etc)
+
la reconnait (l'analyse) pour vérifier sa correction
+
émet éventuellement un message d'erreur
+
le traduit dans le langage cible
+
+
Le processus de compilation est généralement analysé comme une série de phases.
+
Phase: opération logiquement distincte, qui à partir d'une représentation du programme, produit une autre représentation en entrée d'une phase
+
=== PHASES ===
+1. Analyse lexicale ]
+2. Analyse syntaxique ] Phases d'analyse
+3. Analyse sémantique ]
+4. Génération du code intermédiaire ]
+5. Optimisation du code intermédiaire ] Phases de synthèse
+6. Génération du code objet (exécutable) ]
+
Compilateur : Phases d'analyse
+
Analyse lexicale
+
+
Consiste à lire le texte source (char par char), et produit une chaine d'instructions séparées par un caractère particulier appelé séparateur
+
Former des unités lexicales appelées lexèmes
+
Eliminer le informations inutiles (commentaires, etc)
+
Présenter une chaine d'entree à l'analyseur syntaxique
+
+
Un lexème peut être défini comme une unité propre à un langage considéré:
+
+
mots-clés, les identificateurs, les séparateurs, etc
+
il y a correspondance avec la table des symboles
+
+
On peut distinguer 2 types de lexèmes (ex. Fortran)
+
+
mots spécifiques du langage (if, for, struct, ...)
+
identificateurs
+
+
Analyse syntaxique
+
+
Consiste à prélever des instructions de la chaine délivrée par l'analyseur lexical et déterminer si chacune est conforme aux règles de syntaxe du langage considéré.
+
Vérification en construisant l'arbre syntaxique de l'instruction à analyser
+
Les feuilles de l'arbre doivent être les lexèmes consistuant l'instruction
+
Pour construire l'arbre, l'analyseur syntaxique dispose de règles de syntaxe (grammaire) du langage considéré
+
+
Analyse sémantique
+
+
Destinée à la détection d'erreurs sur la manipulation des objets du langage de programmation, et en particulier au contrôle de types
+
Exemple: contrôle à travers l'arbre syntaxique, fourni par l'analyseur syntaxique, si chaque opérateur est appliqué à de opérandes ayant les types permis par la spécification du langage considéré
+
Elle n'existe pas dans tous les compilateurs; apparue avec les langages typés (Pascal)
+
+
Compilateur : Phases de synthèse
+
La génération du code intermédiaire
+
+
Utilisation des variables intermédiaires
+
Choix de l'ordre pour faire le calcul
+
+
L'optimisation du code intermédiaire
+
+
Amélioration du code intermédiaire
+
Réduction du nombre de variables de d'instructions
+
+
La génération du code cible
+
+
Choix des emplacements mémoire pour les variables
+
Assignation des variables aux registres
+
+
Compilateur : Phases
+
La gestion des erreurs
+
+
ANalyse lexicale: caractère illégal, identificateur trop long, nombre illégal
+
Analyse syntaxique: parenthèses manquantes au sens général( (), begin, etc)
+
Analyse sémantique: opérateur incompatible avec le type de l'objet considéré, dépassement d'intervalle, division par 0
+
Génération du code cible: dépassement de capacité, etc
+
Table des symboles: double déclaration
+
+
La génération de la table des symboles
+
+
Enregistre les identificateurs et les attributs (emplacement mémoire, typage, etc)
+
Chaque identificateur (variable) a une entrée dans la table des symboles
+
L'analyseur lexical crée une entrée dans la table des symboles à chaque fois qu'il rencontre un nouvel identificateur
+
+
Outils pour la compilation
+
Correction
+
+
Entrée invalide détectée ?
+
Sortie conforme aux attentes ?
+
Outil de prédilection = théorie des langages
+
+
Efficacité
+
+
Faut-il attendre le résultat de la compilation ?
+
Outil de prédilection = algorithmique
+
+
Bonne conception du logiciel
+
+
Logiciel facile à modifier/étendre ?
+
Outil de prédilection = Génie Logiciel (GL)
+
+
Thérie de langages pour la compilation ?
+
Permet de définir rigoureusement et reconnaitre algorithmiquement (pour les langages source et cible):
+
+
Leur vocabulaire ou lexique : les mots autorisés
+
+
analyse lexicale
+
automates à nombre fini d'états
+
+
Leur syntaxe: la structure des phrases autorisées:
+
+
analyse syntaxique
+
automates à pile, grammaires algébriques
+
+
Leur sèmantique: la signification des phrases autorisées
+
+
analyse sémantique
+
grammaires attribuées
+
+
+
Programmation et modalités de contrôle
+
Programme
+
+
Introduction
+
Langages
+
Grammaires
+
Automates finis
+
Expressions régulières
+
...
+
+
Modalités de contrôle des connaissances:
+
+
Contrôle continue écrit = 30%
+
Examen écrit = 70%
+
+
+
diff --git a/theoriedeslangagesetcompilation/cours/introduction.md b/theoriedeslangagesetcompilation/cours/introduction.md
index e5b117f..e814ec7 100644
--- a/theoriedeslangagesetcompilation/cours/introduction.md
+++ b/theoriedeslangagesetcompilation/cours/introduction.md
@@ -2,6 +2,7 @@
### Motivations
Concept de **langage formel**
+
- créé par les linguistes pour décrire les langages naturels
- effectuer des traductions automatiques
- Noam CHOMSKY: modèle mathématique pour les grammaires
@@ -21,23 +22,29 @@ Pourquoi étudier les langages formels ?
### Un compilateur ?
- PROGRAMME SOURCE => COMPILATEUR => PROGRAMME CIBLE
- ||
- v
- nessages d'erreur
+```
+ PROGRAMME SOURCE
+ |
+ V
+ COMPILATEUR -> messages d'erreur
+ |
+ V
+ PROGRAMME CIBLE
+```
Un compilateur est un **programme** qui
+
- prend en entrée une **donnée textuelle** source (programme, donnée xml, fichier de configuration, etc)
- la reconnait (l'analyse) pour vérifier sa correction
- émet éventuellement un **message d'erreur**
- le traduit dans le **langage cible**
-Le processus de compilation est généralement analysé comme une série de phases:
-- Phase: opération logiquement distincte, qui à partir d'une représentation du programme, produit une autre représentation en entrée d'une phase
+Le processus de compilation est généralement analysé comme une série de phases.
+**Phase**: opération logiquement distincte, qui à partir d'une représentation du programme, produit une autre représentation en entrée d'une phase
-Phases:
+ === PHASES ===
1. Analyse lexicale ]
2. Analyse syntaxique ] Phases d'analyse
3. Analyse sémantique ]
@@ -56,12 +63,14 @@ Phases:
Un **lexème** peut être défini comme une unité propre à un langage considéré:
+
- mots-clés, les identificateurs, les séparateurs, etc
- il y a correspondance avec la table des symboles
On peut distinguer 2 types de lexèmes (ex. Fortran)
+
1. mots spécifiques du langage (if, for, struct, ...)
-2. identificateurs (
+2. identificateurs
##### Analyse syntaxique
@@ -128,6 +137,7 @@ On peut distinguer 2 types de lexèmes (ex. Fortran)
### Thérie de langages pour la compilation ?
Permet de définir rigoureusement et reconnaitre algorithmiquement (pour les langages source et cible):
+
- Leur **vocabulaire** ou **lexique** : les mots autorisés
- analyse lexicale
- automates à nombre fini d'états
@@ -141,7 +151,8 @@ Permet de définir rigoureusement et reconnaitre algorithmiquement (pour les lan
### Programmation et modalités de contrôle
-Programme
+**Programme**
+
- Introduction
- Langages
- Grammaires
@@ -149,6 +160,7 @@ Programme
- Expressions régulières
- ...
-Modalités de contrôle des connaissances:
+**Modalités de contrôle des connaissances:**
+
- Contrôle continue écrit = 30%
- Examen écrit = 70%