Test pandoc (markdown+latex->html)
This commit is contained in:
xdrm-brackets
parent
a806298b1b
commit
9066b77eb1
|
|
@ -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;
|
||||
}
|
||||
}
|
||||
|
|
@ -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
|
||||
|
||||
|
|
|
|||
|
|
@ -0,0 +1,3 @@
|
|||
#!/bin/sh
|
||||
|
||||
pandoc -f markdown -t html5 --css ../../../dependencies/pandoc.css introduction.md -o compiled/introduction.html
|
||||
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -0,0 +1,131 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="generator" content="pandoc">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
|
||||
<title></title>
|
||||
<style type="text/css">code{white-space: pre;}</style>
|
||||
<link rel="stylesheet" href="../../../dependencies/pandoc.css">
|
||||
<!--[if lt IE 9]>
|
||||
<script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
|
||||
<![endif]-->
|
||||
</head>
|
||||
<body>
|
||||
<h1 id="chapitre-i---langages">Chapitre I - Langages</h1>
|
||||
<h3 id="définition-dun-langage">Définition d'un langage</h3>
|
||||
<p>Un langage est un ensemble de mots qui peut être défini :</p>
|
||||
<ul>
|
||||
<li>En extension: liste exhaustive de tous les mots du langage (ex: dictionnaire)</li>
|
||||
<li>En compréhension: on commence une énumération (<span class="math inline"><em>L</em> = {<em>a</em><em>b</em>, <em>a</em><em>a</em><em>b</em><em>b</em>, <em>a</em><em>a</em><em>a</em><em>b</em><em>b</em><em>b</em>, ...}</span>)</li>
|
||||
<li>En intension: on se donne des règles. Exemple: tous les mots formés de <span class="math inline"><em>a</em></span> et <span class="math inline"><em>b</em></span> qui comportent autant d'occurences de <span class="math inline"><em>a</em></span> que de <span class="math inline"><em>b</em></span> et dont tous les <span class="math inline"><em>a</em></span> sont en première positions.</li>
|
||||
<li>Inductivement: outils de définitions compacts de langages</li>
|
||||
</ul>
|
||||
<h5 id="lambiguité">L'ambiguité</h5>
|
||||
<p><strong>Une phrase ambigue</strong></p>
|
||||
<blockquote>
|
||||
<p>phrase à laquelle on peut attribuer plusieurs sens (en informatique, on parle de <em>conflit</em>).</p>
|
||||
</blockquote>
|
||||
<p><strong>Une interprétation d'une phrase ambigue</strong></p>
|
||||
<blockquote>
|
||||
<p>sens que l'on attribue à cette phrase. (exemple: <span class="math inline">2 + 3 × 4</span> peut se calculer différemment en fonction des règles de calcul)</p>
|
||||
</blockquote>
|
||||
<h3 id="définitions-inductives">Définitions inductives</h3>
|
||||
<p>Les <strong>définitions inductives</strong> (recursive definitions)</p>
|
||||
<p><strong>idée</strong>: on procède en 3 étapes</p>
|
||||
<ol type="1">
|
||||
<li>On se donne une <strong>base</strong> d'objets appartenant à l'ensemble que l'on veut définir<br />
|
||||
</li>
|
||||
<li>On se donne des <strong>règles</strong> pour construire d'autres objets de l'ensemble à partir d'objets de la base ou d'objets déjà construits.<br />
|
||||
</li>
|
||||
<li>On déclare que les seuls objets de l'ensemble sont ceux construits en <strong>appliquant</strong> un nombre <strong>fini</strong> de fois des règles.</li>
|
||||
</ol>
|
||||
<p><em>On n'exige pas que la base soit minimale</em></p>
|
||||
<p><em>Souvent on donne une définition inductive sous la forme <span class="math inline"><em>b</em><em>a</em><em>s</em><em>e</em> + <em>r</em><em>è</em><em>g</em><em>l</em><em>e</em><em>s</em></span></em></p>
|
||||
<p><strong>Exemple</strong>: Définissons l'ensemble <span class="math inline"><em>P</em><em>A</em><em>I</em><em>R</em></span> des entiers pairs positifs:</p>
|
||||
<ol type="1">
|
||||
<li>Base: 2 appartien à <span class="math inline"><em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li>Règle: Si <span class="math inline"><em>x</em></span> est dans <span class="math inline"><em>P</em><em>A</em><em>I</em><em>R</em></span>, alors <span class="math inline"><em>x</em> + 2</span> est dans <span class="math inline"><em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
</ol>
|
||||
<ul>
|
||||
<li>Pour montrer qu'un nombre est dans <span class="math inline"><em>P</em><em>A</em><em>I</em><em>R</em></span>, on exhibera une succession d'application des règles</li>
|
||||
<li>La définition inductive d'un ensemble n'est pas unique</li>
|
||||
<li>exemple 2:
|
||||
<ol type="1">
|
||||
<li>Base: 2 est dans <span class="math inline"><em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
<li>Règle: si <span class="math inline"><em>x</em></span> et <span class="math inline"><em>y</em></span> sont dans <span class="math inline"><em>P</em><em>A</em><em>I</em><em>R</em></span>, alors <span class="math inline"><em>x</em> + <em>y</em></span> est dans <span class="math inline"><em>P</em><em>A</em><em>I</em><em>R</em></span></li>
|
||||
</ol></li>
|
||||
<li>Avantage de l'exemple 2: les preuves qu'un nombre appartient à <span class="math inline"><em>P</em><em>A</em><em>I</em><em>R</em></span> sont plus courtes.</li>
|
||||
</ul>
|
||||
<p>Principe pour décrire les langages par une <strong>grammaire</strong> (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.</p>
|
||||
<h3 id="définitions-sur-les-langages">Définitions sur les langages</h3>
|
||||
<h5 id="propriétés-de-lalphabet">Propriétés de l'alphabet</h5>
|
||||
<p><strong>Définition</strong></p>
|
||||
<blockquote>
|
||||
<p>Un alphabet <span class="math inline"><em>Σ</em></span> est un ensemble <strong>fini</strong> de smyboles.<br />
|
||||
<em>exemple</em>: <span class="math inline"><em>Σ</em> = {<em>a</em>, <em>b</em>}</span></p>
|
||||
</blockquote>
|
||||
<h5 id="propriétés-du-mot">Propriétés du mot</h5>
|
||||
<p><strong>Définition</strong></p>
|
||||
<blockquote>
|
||||
<p>Un <strong>mot</strong> (appelé aussi chaine) <span class="math inline"><em>X</em></span> sur <span class="math inline"><em>Σ</em></span> est une suite finie de symboles de <span class="math inline"><em>Σ</em></span> juxtaposés.</p>
|
||||
</blockquote>
|
||||
<p><strong>Longueur</strong></p>
|
||||
<blockquote>
|
||||
<p>Nombre de symboles de l'alphabet composant le mot.</p>
|
||||
</blockquote>
|
||||
<blockquote>
|
||||
<ul>
|
||||
<li>notée <span class="math inline">|<em>X</em>|</span></li>
|
||||
<li><span class="math inline">|<em>X</em>|<sub><em>a</em></sub></span> dénote le nombre d'occurences de la lettre <span class="math inline"><em>a</em></span> dans le mot <span class="math inline"><em>X</em></span></li>
|
||||
<li><em>exemple</em>: <span class="math inline"><em>Σ</em> = {<em>a</em>, <em>b</em>}, <em>X</em> = <em>a</em><em>a</em><em>b</em><em>b</em><em>a</em><em>a</em></span> est un mot sur <span class="math inline"><em>Σ</em></span>; <span class="math inline">|<em>X</em>|=5</span>, et <span class="math inline">|<em>X</em>|<sub><em>a</em></sub> = 4</span></li>
|
||||
</ul>
|
||||
</blockquote>
|
||||
<p><strong>mot vide</strong></p>
|
||||
<blockquote>
|
||||
<p>Le <strong>mot vide</strong> ne contenant aucun symbole est noté <span class="math inline"><em>ϵ</em></span>, <span class="math inline">|<em>ϵ</em>|=0</span><br />
|
||||
- <span class="math inline"><em>ϵ</em></span> peut être un mot d'un langage, mais n'est pas une lettre de l'alphabet</p>
|
||||
</blockquote>
|
||||
<h5 id="opérations-du-mot">Opérations du mot</h5>
|
||||
<p><strong>Concaténation</strong></p>
|
||||
<blockquote>
|
||||
<p>Concaténation: soit <span class="math inline"><em>X</em></span> et <span class="math inline"><em>Y</em></span> deux mots de <span class="math inline"><em>Σ</em></span>. On appelle <strong>concaténation</strong> de <span class="math inline"><em>X</em></span> et de <span class="math inline"><em>Y</em></span>, le mot <span class="math inline"><em>X</em><em>Y</em></span></p>
|
||||
</blockquote>
|
||||
<blockquote>
|
||||
<ul>
|
||||
<li>Notation: <span class="math inline"><em>X</em>.<em>Y</em></span> ou <span class="math inline"><em>X</em><em>Y</em></span></li>
|
||||
<li>C'est une loi de formation de mots <em>associative</em>, <em>non commutative</em>, et qui admet <span class="math inline"><em>ϵ</em></span> comme <em>élèment neutre</em>: <span class="math inline"><em>X</em><em>ϵ</em> = <em>ϵ</em><em>X</em> = <em>X</em></span></li>
|
||||
<li>Forme condensée de la concaténation (puissance): <span class="math inline"><em>X</em><sup><em>n</em></sup> = <em>X</em><em>X</em><em>X</em><em>X</em>...</span> n fois, <span class="math inline"><em>X</em><sup>0</sup> = <em>ϵ</em></span></li>
|
||||
</ul>
|
||||
</blockquote>
|
||||
<p><strong>Préfixe</strong></p>
|
||||
<blockquote>
|
||||
<p>Tout mot <span class="math inline"><em>f</em></span> (mot vide inclus) qui permet d'écrire <span class="math inline"><em>X</em> = <em>f</em><em>g</em></span></p>
|
||||
</blockquote>
|
||||
<p><strong>Suffixe</strong></p>
|
||||
<blockquote>
|
||||
<p>Tout mot <span class="math inline"><em>g</em></span> (mot vide inclus) qui permet d'écrire <span class="math inline"><em>X</em> = <em>f</em><em>g</em></span></p>
|
||||
</blockquote>
|
||||
<p><strong>Préfixe/Suffixe propre</strong></p>
|
||||
<blockquote>
|
||||
<p><span class="math inline"><em>U</em></span> est un préfixe/suffixe propre de <span class="math inline"><em>X</em></span> <strong>ssi</strong> <span class="math inline"><em>U</em></span> est préfixe/suffixe de <span class="math inline"><em>X</em></span> et <span class="math inline"><em>U</em></span> est différent de <span class="math inline"><em>X</em></span> - remarque: <span class="math inline"><em>X</em></span> est préfixe ou suffixe de lui-même</p>
|
||||
</blockquote>
|
||||
<p><strong>Facteur/sous-mot</strong></p>
|
||||
<blockquote>
|
||||
<p>Un facteur, ou sous-mot est tout mot <span class="math inline"><em>g</em></span> qui permet d'écrire <span class="math inline"><em>X</em> = <em>f</em><em>g</em><em>h</em></span>, avec <span class="math inline"><em>f</em></span> et <span class="math inline"><em>h</em></span> non vides.</p>
|
||||
</blockquote>
|
||||
<p><strong>Fermeture de Kleen</strong></p>
|
||||
<blockquote>
|
||||
<p>Soit <span class="math inline"><em>Σ</em></span> un alphabet, on appelle <strong>fermeture de Kleen</strong> de <span class="math inline"><em>Σ</em></span>, noté <span class="math inline"><em>Σ</em><sup>*</sup></span>. L'ensemble est défini inductivement de la façon suivante :</p>
|
||||
</blockquote>
|
||||
<blockquote>
|
||||
<ul>
|
||||
<li>base: tous les symboles de <span class="math inline"><em>Σ</em></span> ainsi que le mot vide sont dans <span class="math inline"><em>Σ</em><sup>*</sup></span></li>
|
||||
<li>règle: si <span class="math inline"><em>x</em></span> et <span class="math inline"><em>y</em></span> sont dans <span class="math inline"><em>Σ</em><sup>*</sup></span>, alors <span class="math inline"><em>x</em><em>y</em></span> est dans <span class="math inline"><em>Σ</em><sup>*</sup></span><br />
|
||||
<span class="math inline"><em>Σ</em><sup>*</sup></span> est l'ensemble des mots sur <span class="math inline"><em>Σ</em></span>, de longueur finie, plus le mot vide.</li>
|
||||
<li>on note <span class="math inline"><em>Σ</em><sup>+</sup> = <em>Σ</em><sup>*</sup> \ <em>ϵ</em></span></li>
|
||||
</ul>
|
||||
</blockquote>
|
||||
<h3 id="opérations-sur-les-langages">Opérations sur les langages</h3>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -0,0 +1,166 @@
|
|||
<!DOCTYPE html>
|
||||
<html>
|
||||
<head>
|
||||
<meta charset="utf-8">
|
||||
<meta name="generator" content="pandoc">
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, user-scalable=yes">
|
||||
<title></title>
|
||||
<style type="text/css">code{white-space: pre;}</style>
|
||||
<link rel="stylesheet" href="../../../dependencies/pandoc.css">
|
||||
<!--[if lt IE 9]>
|
||||
<script src="//cdnjs.cloudflare.com/ajax/libs/html5shiv/3.7.3/html5shiv-printshiv.min.js"></script>
|
||||
<![endif]-->
|
||||
</head>
|
||||
<body>
|
||||
<h3 id="motivations">Motivations</h3>
|
||||
<p>Concept de <strong>langage formel</strong></p>
|
||||
<ul>
|
||||
<li>créé par les linguistes pour décrire les langages naturels
|
||||
<ul>
|
||||
<li>effectuer des traductions automatiques</li>
|
||||
</ul></li>
|
||||
<li>Noam CHOMSKY: modèle mathématique pour les grammaires
|
||||
<ul>
|
||||
<li>1958: langage ALGOL décrit à l'aide d'une grammaire "Hors-Contexte" (notations BNF: description d'un langage de prog.)</li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<p>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</p>
|
||||
<h3 id="un-compilateur">Un compilateur ?</h3>
|
||||
<pre><code> PROGRAMME SOURCE
|
||||
|
|
||||
V
|
||||
COMPILATEUR -> messages d'erreur
|
||||
|
|
||||
V
|
||||
PROGRAMME CIBLE</code></pre>
|
||||
<p>Un compilateur est un <strong>programme</strong> qui</p>
|
||||
<ul>
|
||||
<li>prend en entrée une <strong>donnée textuelle</strong> source (programme, donnée xml, fichier de configuration, etc)</li>
|
||||
<li>la reconnait (l'analyse) pour vérifier sa correction</li>
|
||||
<li>émet éventuellement un <strong>message d'erreur</strong></li>
|
||||
<li>le traduit dans le <strong>langage cible</strong></li>
|
||||
</ul>
|
||||
<p>Le processus de compilation est généralement analysé comme une série de phases.</p>
|
||||
<p><strong>Phase</strong>: opération logiquement distincte, qui à partir d'une représentation du programme, produit une autre représentation en entrée d'une phase</p>
|
||||
<pre><code>=== 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) ]</code></pre>
|
||||
<h3 id="compilateur-phases-danalyse">Compilateur : Phases d'analyse</h3>
|
||||
<h5 id="analyse-lexicale">Analyse lexicale</h5>
|
||||
<ul>
|
||||
<li>Consiste à lire le texte source (char par char), et produit une <strong>chaine d'instructions</strong> séparées par un caractère particulier appelé <strong>séparateur</strong></li>
|
||||
<li>Former des unités lexicales appelées <strong>lexèmes</strong></li>
|
||||
<li>Eliminer le informations inutiles (commentaires, etc)</li>
|
||||
<li>Présenter une chaine d'entree à l'analyseur syntaxique</li>
|
||||
</ul>
|
||||
<p>Un <strong>lexème</strong> peut être défini comme une unité propre à un langage considéré:</p>
|
||||
<ul>
|
||||
<li>mots-clés, les identificateurs, les séparateurs, etc</li>
|
||||
<li>il y a correspondance avec la table des symboles</li>
|
||||
</ul>
|
||||
<p>On peut distinguer 2 types de lexèmes (ex. Fortran)</p>
|
||||
<ol type="1">
|
||||
<li>mots spécifiques du langage (if, for, struct, ...)</li>
|
||||
<li>identificateurs</li>
|
||||
</ol>
|
||||
<h5 id="analyse-syntaxique">Analyse syntaxique</h5>
|
||||
<ul>
|
||||
<li>Consiste à prélever des instructions de la chaine délivrée par l'analyseur lexical et déterminer si chacune est conforme aux <strong>règles de syntaxe</strong> du langage considéré.</li>
|
||||
<li>Vérification en construisant l'<strong>arbre syntaxique</strong> de l'instruction à analyser</li>
|
||||
<li>Les feuilles de l'arbre doivent être les <strong>lexèmes</strong> consistuant l'instruction</li>
|
||||
<li>Pour construire l'arbre, l'analyseur syntaxique dispose de <strong>règles de syntaxe</strong> (grammaire) du langage considéré</li>
|
||||
</ul>
|
||||
<h5 id="analyse-sémantique">Analyse sémantique</h5>
|
||||
<ul>
|
||||
<li>Destinée à la détection d'erreurs sur la manipulation des objets du langage de programmation, et en particulier au <strong>contrôle de types</strong></li>
|
||||
<li><strong>Exemple</strong>: 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é</li>
|
||||
<li>Elle n'existe pas dans tous les compilateurs; apparue avec les langages typés (Pascal)</li>
|
||||
</ul>
|
||||
<h3 id="compilateur-phases-de-synthèse">Compilateur : Phases de synthèse</h3>
|
||||
<h5 id="la-génération-du-code-intermédiaire">La génération du code intermédiaire</h5>
|
||||
<ul>
|
||||
<li>Utilisation des variables intermédiaires</li>
|
||||
<li>Choix de l'ordre pour faire le calcul</li>
|
||||
</ul>
|
||||
<h5 id="loptimisation-du-code-intermédiaire">L'optimisation du code intermédiaire</h5>
|
||||
<ul>
|
||||
<li>Amélioration du code intermédiaire</li>
|
||||
<li>Réduction du nombre de variables de d'instructions</li>
|
||||
</ul>
|
||||
<h5 id="la-génération-du-code-cible">La génération du code cible</h5>
|
||||
<ul>
|
||||
<li>Choix des emplacements mémoire pour les variables</li>
|
||||
<li>Assignation des variables aux registres</li>
|
||||
</ul>
|
||||
<h3 id="compilateur-phases">Compilateur : Phases</h3>
|
||||
<h5 id="la-gestion-des-erreurs">La gestion des erreurs</h5>
|
||||
<ul>
|
||||
<li>ANalyse lexicale: caractère illégal, identificateur trop long, nombre illégal</li>
|
||||
<li>Analyse syntaxique: parenthèses manquantes au sens général( (), begin, etc)</li>
|
||||
<li>Analyse sémantique: opérateur incompatible avec le type de l'objet considéré, dépassement d'intervalle, division par 0</li>
|
||||
<li>Génération du code cible: dépassement de capacité, etc</li>
|
||||
<li>Table des symboles: double déclaration</li>
|
||||
</ul>
|
||||
<h5 id="la-génération-de-la-table-des-symboles">La génération de la table des symboles</h5>
|
||||
<ul>
|
||||
<li>Enregistre les identificateurs et les attributs (emplacement mémoire, typage, etc)</li>
|
||||
<li>Chaque identificateur (variable) a une entrée dans la table des symboles</li>
|
||||
<li>L'analyseur lexical crée une entrée dans la table des symboles à chaque fois qu'il rencontre un nouvel identificateur</li>
|
||||
</ul>
|
||||
<h3 id="outils-pour-la-compilation">Outils pour la compilation</h3>
|
||||
<h5 id="correction">Correction</h5>
|
||||
<ul>
|
||||
<li>Entrée invalide détectée ?</li>
|
||||
<li>Sortie conforme aux attentes ?</li>
|
||||
<li>Outil de prédilection = <strong>théorie des langages</strong></li>
|
||||
</ul>
|
||||
<h5 id="efficacité">Efficacité</h5>
|
||||
<ul>
|
||||
<li>Faut-il attendre le résultat de la compilation ?</li>
|
||||
<li>Outil de prédilection = <strong>algorithmique</strong></li>
|
||||
</ul>
|
||||
<h5 id="bonne-conception-du-logiciel">Bonne conception du logiciel</h5>
|
||||
<ul>
|
||||
<li>Logiciel facile à modifier/étendre ?</li>
|
||||
<li>Outil de prédilection = <strong>Génie Logiciel (GL)</strong></li>
|
||||
</ul>
|
||||
<h3 id="thérie-de-langages-pour-la-compilation">Thérie de langages pour la compilation ?</h3>
|
||||
<p>Permet de définir rigoureusement et reconnaitre algorithmiquement (pour les langages source et cible):</p>
|
||||
<ul>
|
||||
<li>Leur <strong>vocabulaire</strong> ou <strong>lexique</strong> : les mots autorisés
|
||||
<ul>
|
||||
<li>analyse lexicale</li>
|
||||
<li>automates à nombre fini d'états</li>
|
||||
</ul></li>
|
||||
<li>Leur <strong>syntaxe</strong>: la structure des phrases autorisées:
|
||||
<ul>
|
||||
<li>analyse syntaxique</li>
|
||||
<li>automates à pile, grammaires algébriques</li>
|
||||
</ul></li>
|
||||
<li>Leur <strong>sèmantique</strong>: la signification des phrases autorisées
|
||||
<ul>
|
||||
<li>analyse sémantique</li>
|
||||
<li>grammaires attribuées</li>
|
||||
</ul></li>
|
||||
</ul>
|
||||
<h3 id="programmation-et-modalités-de-contrôle">Programmation et modalités de contrôle</h3>
|
||||
<p><strong>Programme</strong></p>
|
||||
<ul>
|
||||
<li>Introduction</li>
|
||||
<li>Langages</li>
|
||||
<li>Grammaires</li>
|
||||
<li>Automates finis</li>
|
||||
<li>Expressions régulières</li>
|
||||
<li>...</li>
|
||||
</ul>
|
||||
<p><strong>Modalités de contrôle des connaissances:</strong></p>
|
||||
<ul>
|
||||
<li>Contrôle continue écrit = 30%</li>
|
||||
<li>Examen écrit = 70%</li>
|
||||
</ul>
|
||||
</body>
|
||||
</html>
|
||||
|
|
@ -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%
|
||||
|
|
|
|||
Loading…
Reference in New Issue