LICENCE D’INFORMATIQUE

Université de Rennes 1

EXAMEN DE CMPL
Jeudi 16 juin 2016 à 8h
Durée : 2 heures
Notation : Exercice 1 = 5 points ; Exercice 2 = 7 points ; Exercice 3 = 3 points ;
Exercice 4= 5 points
Nombre de pages : 5 (4 pages de sujet + 1 page grammaire langage Projet)
Seul document autorisé : résumé personnel au format A4 recto-verso

EXERCICE 1 (5 points) - Grammaire LL(1) et analyse DGD

Soit la grammaire hors contexte suivante :
G = (VN , VT , P , S) , VN = {S, X, Y, T, Z, U} , VT = {a, b, c, d, e, f, #}
où l’ensemble P des productions est :
S  X f U | #
X  a Y Z d | T Z
Y  c Y | 
T  d Y | 
Z  e Y | b X f | 
U  Y f | a
Cette grammaire est LL(1).
1.1 Donner, sans fournir les calculs intermédiaires sur votre copie, le prédicat
NULL pour chaque non-terminal, l’ensemble PREMIER de chaque partie
droite de règle et l’ensemble SUIVANT de chaque non-terminal nécessitant
le calcul de cet ensemble.
1.2 Donner la procédure Java associée au non-terminal X dans l’analyseur syn-
taxique DGD procédural déduit de G.

1/5
 EXERCICE 2 (7 points) - Compilation

On considère le langage PROJET, initialement sans procédures ni compilation

séparée, que l’on souhaite enrichir par de nouvelles constructions.
On suppose déclarés et disponibles :
- la table des symboles tabSymb[code, categorie, type, info], d’indice de
remplissage it,
- le tableau programme objet po d’indice de remplissage ipo,
- la pile de reprise pileRep,
- la variable tCour,
- les instructions de la machine à pile MAPILE
RESERVER, EMPILER, CONTENUG, AFFECTERG, OU, ET, NON, INF, INFEG, SUP, SUPEG,
EG, DIFF, ADD, SOUS, MUL, DIV, BSIFAUX, BINCOND, LIRENT, LIREBOOL, ECRENT,
ECRBOOL, ARRET.
- les fonctions :
produire, verifEnt, verifBool, pileRep.empiler, pileRep.depiler,
presentIdent, placeIdent, UtilLex.messErr, UtilLex.valNb, UtilLex.numId...

QUESTIONS - (les 3 questions sont indépendantes)

2.1 On ajoute la règle :

primaire : ’produit’ ’(’ expression ’,’ expression ’,’ expression ’)’ ;

où l’exécution de produit (e1 , e2 , e3) délivre vrai si les trois expressions

entières e1, e2 et e3 sont telles que e1 vaut e2 e3 , faux sinon.
Placer les points de génération et donner les traitements associés (code
MAPILE produit et/ou contrôles éventuels) nécessaires à la compilation de
cette nouvelle règle.

2.2 On ajoute l’instruction :

insrepeter : ’repeter’ instructions ’ttq’ expression ;

qui possède la même sémantique que l’instruction do ... while de Java (arrêt
de l’itération lorsque expression vaut faux).
Placer les points de génération et donner les traitements associés (code
MAPILE produit et/ou contrôles éventuels) nécessaires à la compilation de
insrepeter.

2/5
 2.3 On ajoute la règle :
primaire :
’somme_ou_prod’ ’(’ expression (’,’ expression ) ’,’ (’’ | ’’) ’)’;
où somme_ou_prod ( e1 , e2 , ... , en ,  ) délivre la somme des n expressions
entières ei. Ainsi, somme_ou_prod ( 3, 5, 72, 10,  ) délivre 27,
et somme_ou_prod ( e1 , e2 , ... , en , ) délivre le produit des n expressions
entières ei. Ainsi, somme_ou_prod ( 3, 5, 72, 10, ) délivre 1350.

Placer les points de génération et donner les traitements associés (code

MAPILE produit et/ou contrôles éventuels) nécessaires à la compilation de
somme_ou_prod.

EXERCICE 3 (3 points) - Compilation séparée

Soit le module source, écrit dans le langage PROJET :

module m :
def p1, p2 ;
ref q1, q2 fixe (bool) mod (ent) ;
const n = 10 ; b = faux ;
var ent x, y ;
proc p1 mod (ent y)
ADD
var ent x ;
ADD
debut ADD exp3
lire (x) ; ADD exp4
y := xn ; exp5
nbExp == 3 EMPILER exp5
q2 (b) (y) ; EMPILER exp4
exp 4 + exp5

fin ; {de p1} ip -> exp3 + exp 4 + exp5

EMPILER exp3
proc p2 exp2
EMPILER exp2
debut
exp1
lire (y) ; EMPILER exp1

si y>0 alors q1 () () sinon p1 () (x) fsi ;

fin ; {de p2} +
MAPILE +
PileExec

QUESTION
Donner le programme objet m.gen et la liste transExt obtenus en compilant le
module m.
On ne demande pas le descripteur m.desc.

3/5
 EXERCICE 4 (5 points) - Automate fini

On considère une base de données, très simplifiée, de voitures associées à

leur année de première mise en circulation. Un langage L permet de décrire
des opérations d’achat, de vente et d’interrogation sur ces données.
Le langage régulier L est généré par la grammaire suivante :
G = (VT , VN , P , <fichier>)
VT = { achat vente interrogation ident nbentier , ; / }
VN = { <fichier> <opération> <acheter> <vendre> <interroger>
<type_interro> <modèle> <année> }
où l’ensemble P des productions est :
<fichier>  ( <opération> ; ) /
<opération>  <acheter> | <vendre> | <interroger>
<acheter>  achat <modèle> <année>
<vendre>  vente <modèle> ( <année> )
<interroger>  interrogation <type_interro> ( , <type_interro> )
<type_interro>  <modèle> <année> | <modèle> | <année>
<modèle>  ident
<année>  nbentier

QUESTIONS

4.1 Donner le graphe d’un automate fini déterministe reconnaissant L.

4.2 On s’intéresse à l’affichage récapitulatif des ventes. Placer, dans l’automate,
des numéros d’actions et fournir les traitements associés afin :
- d’afficher la liste des voitures vendues,
- d’afficher, en fin d’analyse, le nombre de voitures vendues.
Par exemple, la chaîne d’entrée :
achat Picasso 2012 ; vente Logan 2009 2015 ; vente Espace 2005 2008 2010;
achat Logan 2013 ; vente Espace 2000 2012 ; /
doit produire l’affichage suivant:
Logan: 2009 2015; Espace: 2005 2008 2010; Espace: 2000 2012;
nombre de ventes: 7
On dispose des attributs lexicaux Lex.valNb et Lex.numId (associés respecti-
vement aux terminaux nbentier et ident), et de la fonction Lex.repId utilisée
en TP (permettant d’obtenir la chaîne associée au numId d’un ident).
NB: on considère des chaînes d’entrée sans erreur.

4/5
Grammaire du langage PROJET :
unite : unitprog | unitmodule ;
unitprog :: ’ programme ’ ident ’ : ’ declarations corps ;
unitmodule :: ’ module ’ ident ’ : ’ declarations ;
declarations : partiedef ? partieref ?
consts ?
vars ?
decprocs ? ;
partiedef : ’ def ’ ident ( ’ , ’ ident ) ptvg ;
partieref : ’ ref ’ specif ( ’ , ’ specif ) ptvg ;
specif : ident ( ’ fixe ’ ’ ( ’ type ( ’ , ’ type ) ’ ) ’ ) ?
( ’ mod ’ ’ ( ’ type ( ’ , ’ type ) ’ ) ’ ) ? ;
consts : ’ const ’ ( ident ’ = ’ valeur ptvg )+ ;
vars : ’ var ’ ( type ident ( ’ , ’ ident ) ptvg )+ ;
type : ’ ent ’ | ’ bool ’ ;
decprocs : ( decproc ptvg )+ ;
decproc : ’ proc ’ ident parfixe ? parmod ?
consts ? vars ?
corps ;
ptvg : ’;’ | ;
corps : ’ debut ’ instructions ’ fin ’ ;
parfixe : ’ fixe ’ ’ ( ’ pf ( ’; ’ pf ) ’ ) ’ ;
pf : type ident ( ’ , ’ ident ) ;
parmod : ’ mod ’ ’ ( ’ pm ( ’ ; ’ pm ) ’ ) ’ ;
pm : type ident ( ’ , ’ ident ) ;
instructions : instruction ( ’ ; ’ instruction ) ;
instruction : inssi | inscond
| boucle
| lecture | ecriture
| affouappel
| ;
inssi : ’ si ’ expression ’ alors ’ instructions
( ’ sinon ’ instructions )?
’ fsi ’ ;
inscond : ’ cond ’ expression ’ : ’ instructions
( ’ , ’ expression ’ : ’ instructions )
( ’ aut ’ instructions )? ’ fcond ’ ;
boucle : ’ ttq ’ expression ’ faire ’ instructions ’ fait ’ ;
lecture : ’ lire ’ ’ ( ’ ident ( ’ , ’ ident ) ’) ’ ;
ecriture : ’ ecrire ’ ’ ( ’ expression ( ’ , ’ expression ) ’ ) ’ ;
affouappel : ident ( ’ := ’ expression
| ( effixes ( effmods )? )?
) ;
effixes : ’ ( ’ ( expression ( ’ , ’ expression ) )? ’ ) ’ ;
effmods : ’ ( ’ ( ident ( ’ , ’ ident ) )? ’ ) ’ ;
expression : exp1 ( ’ ou ’ exp1 )* ;
exp1 : exp2 ( ’ et ’ exp2 )* ;
exp2 : ’ non ’ exp2 | exp3 ;
exp3 : exp4 ( ’ = ’ exp4 | ’ <> ’ exp4
| ’ > ’ exp4 | ’ >= ’ exp4
| ’ < ’ exp4 | ’ <= ’ exp4
)? ;
exp4 : exp5 ( ’ ’ exp5 | ’ ’ exp5 )* ;
exp5 : primaire ( ’ ’ primaire | ’ div ’ primaire )* ;
primaire : valeur | ident | ’ ( ’ expression ’ ) ’ ;
valeur : nbentier | ’ ’ nbentier | ’ ’ nbentier | ’ vrai ’ | ’ faux ’ ;

5/5