85 lines
4.8 KiB
Markdown
85 lines
4.8 KiB
Markdown
---
|
|
title: TP Analyse syntaxique
|
|
author: Yohann D'ANELLO
|
|
geometry:
|
|
- top=0.5in
|
|
- bottom=0.5in
|
|
- left=1in
|
|
- right=1in
|
|
...
|
|
|
|
\pagenumbering{gobble}
|
|
|
|
# Analyse lexicale
|
|
|
|
Le fichier `example.l` peut se compiler en un analyseur lexical `example` en appelant simplement la commande `make example`. Il permet à partir d'une entrée textuelle (un fichier, le TTY ou l'entrée standard suivie d'un Ctrl+D) de filter les nombres et de les afficher, sous forme décimale ou hexadécimale. De plus, les mots clés `if`, `then` et `else` sont réécrits en majsucule. Tout le reste est ignoré.
|
|
|
|
Un entier `n` affichera sur la sortie `int(n)`, un entier `0xh` écrit en hexadécimal affichera dans la sortie `hex(n)` où `n` est la représentation décimale de `0xh`.
|
|
|
|
Par exemple sur une entrée :
|
|
|
|
```
|
|
Papa maman ! Faites-moi 1 câlin !
|
|
|
|
if content then
|
|
Oh oui ! Faisons 1 gros câlin ! Tu l'as bien mérité après tes 20/20 que
|
|
tu viens de ramener ! On t'aime à 100% <3
|
|
else
|
|
- Mon enfant, il va falloir que tu vois la vie avec ses 0xFFFFFF couleurs, si tu veux
|
|
espérer avoir des 10aines de câlins ... Va nous acheter une demi-12aine d'œufs.
|
|
- Bouuh ! Je m'en vais pleurer pendant 42 ans.
|
|
* La justice condamna la famille à 14 années de prison et 7832 € d'amende. *
|
|
```
|
|
|
|
Le programme va renvoyer la sortie suivante :
|
|
|
|
```
|
|
int(1)IFTHENint(1)int(20)int(20)int(100)int(3)ELSEhex(16777215)int(10)int(12)int(42)int(14)int(7832)
|
|
```
|
|
|
|
|
|
# Analyse syntaxique
|
|
|
|
Le programme `lang`, après compilation en appelant successivement `make langlex.c` et `make lang`, se comporte comme un interpréteur d'un langage de programmation fait à la main. L'extension attribuée est le `*.my`, même si cela n'est pas obligatoire.
|
|
|
|
Un programme est composé de trois parties :
|
|
|
|
* La déclaration des variables booléennes (faculatif). Cela se fait en écrivant `bool` suivi de la liste des variables booléennes à déclarer séparées par des virgules. La déclaration doit se finir par un point-virgule. Par exemple, on notera `bool x, y, z;` pour déclarer les variables booléenes `x`, `y` et `z`.
|
|
|
|
* De la même manière, on notera `int a, b, c;` pour déclarer les variables entières `a`, `b` et `c` (facultatif). La déclaration des variables entières doit se faire après la déclaration des variables booléennes s'il y en a.
|
|
|
|
* Enfin, le code. Le code est une succession d'instructions séparées par des point-virgules. Il existe 4 types d'instructions :
|
|
* L'affectation, de la forme `x := expr` où `x` est une variable déclarée et `expr` une expression du même type que `x`.
|
|
* Un test conditionnel, de la forme `if cond then stmt1 else stmt2` où `cond` est une expression booléenne et `stmt1` et `stmt2` deux blocs d'instructions. L'interprétation est naturelle : si la condition `cond` vaut `true`, on exécute le bloc `stmt1`, sinon on évalue le bloc `stmt2`. La partie `else stmt2` est facultative. Le problème du `dangling else` est résolu de la même manière qu'en C : le premier `else` porte sur le premier `if`.
|
|
* Une boucle de la forme `while cond do stmt od` où `cond` est une expression booléenne et `stmt` une suite d'instructions. L'expression `cond` sera évaluée à chaque passage de boucle, et on reste dans la boucle tant que que la condition vaut `true`.
|
|
* Un affichage des variables. Le code doit être de la forme `print list` où `list` est la liste des variables à afficher, séparées par des virgules. La fonction fonctionne à la fois avec des variables booléennes et des variables entières.
|
|
|
|
Une expression peut être de différentes formes. Chaque type d'expression est associée à une "classe" : booléen ou entier, ou les deux.
|
|
|
|
* La valeur d'une variable (du type de la variable)
|
|
* Un ou exclusif de deux expressions booléennes (renvoie un booléen)
|
|
* La disjonction de deux expressions booléennes (renvoie un booléen)
|
|
* La conjection de deux expressions booléennes (renvoie un booléen)
|
|
* L'équivalence deux expressions booléennes (renvoie un booléen)
|
|
* Une négation d'une expression booléenne (renvoie un booléen)
|
|
* `true` (booléen pour dire vrai)
|
|
* `false` (booléen pour dire faux)
|
|
* Une expression entre parenthèse (du type de ce qui est entre parenthèses)
|
|
* La somme de deux expressions entières (renvoie un entier)
|
|
* Le produit de deux expressions entières (renvoie un entier)
|
|
* La comparaison par inégalité stricte entre deux expression entières (renvoie un booléen)
|
|
* L'égalité entre deux expressions entières (renvoie un booléen)
|
|
|
|
Les priorités opérations sont les mêmes qu'en C :
|
|
|
|
1. La négation booléenne
|
|
2. La mutliplication entière
|
|
3. L'addition entière
|
|
4. L'inégalité stricte entre entiers
|
|
5. L'égalité entière
|
|
6. L'équivalence booléenne
|
|
7. La conjonction
|
|
8. La disjonction (éventuellement exclusive)
|
|
|
|
Lors de l'évaluation des expressions, les types sont correctement vérifiés.
|