Vous êtes sur la page 1sur 5

Nom

Plier ici

Prenom

Ne a

Le

p

p

Facult´e des Sciences Licence 3 Informatique

Compilation

Note

sur 20

Sciences Licence 3 Informatique Compilation Note sur 20 Cette feuille sera cachet´ee par vos soins au

Cette feuille sera cachet´ee par vos soins au moyen de colle, agraphes ou papier adh´esif apr`es avoir rabattu le triangle noirci. Il est de votre responsabilit´e de cacheter la feuille. Dans le cas contraire, vous acceptez implicitement que

la correction de votre copie ne soit pas anonyme.

Examen partiel du 18 mai 2009

Dur´ee 2h. Tous documents autoris´es. Les questions sont ind´ependantes.

I . Analyse lexicale (1 pt). Dans le langage Pascal, une constante caract`ere s’´ecrit entre , par

exemple ’a’. Le caract`ere ne peut ˆetre une fin de ligne. Le caract`ere doit ˆetre doubl´e (’’’’).
´

Ecrire une expression r´eguli`ere pour reconnaˆıtre les constantes caract`eres de Pascal.

r´eponse :

"’"([^\n’]|"’’")"’"

II . Analyse lexicale (1 pt).

exemple 1_234_567, c’est

une expression r´eguli`ere qui reconnaˆıt ces nombres (et uniquement ceux l`a). r´eponse :

Le langage Ada permet d’´ecrire les nombres entiers comme par

dire qu’on peut d´ecouper le nombre par tranche de 3 chiffres. Donner

[0-9]{1,3}(

_([0-9]{3}))*

ou encore

[0-9]([0-9][0-9]?)?(_[0-9][0-9][0-9])*

III . Grammaires non contextuelles (2 pts).

gage a n b m , n, m 0, n

= m

r´eponse :

SaSb // on produit autant de a que de b SA, Aa | Aa // on produit des a en plus SB, Bb | Bb // ou on produit des b en plus

Donnez une grammaire qui engendre le lan-

´

IV . Grammaires non contextuelles (2 pts).

semble des d´eclarations C non parenth´es´ees, comme par exemple int a, t[3], *p, m[5][7], **x[2][3]; Types, identificateurs et nombres seront des lex`emes. r´eponse :

Ecrire une grammaire qui produit le sous en-

dc

dvs dv

dv

dt

type dvs

| dvs

| dt

* dv

ident |

dt

;

, dv

[

nombre

]

V . Grammaires attribu´ees (3 pts). Donnez une grammaire bison ou JavaCC qui reconnaˆıt le langage des polynˆomes comme 3x^5 - x^4 + 2x - 8 (3x 5 2x 4 + 2x 8), en v´erifiant que les degr´es sont donn´es dans l’ordre croissant. Les coefficients et les degr´es seront des lex`emes (les coefficients peuvent ˆetre r´eels mais pas les degr´es). Pr´ecisez si vous avez choisi bison ou JavaCC. r´eponse :

bison JavaCC P : M { $$ = $1; } void P() : { int
bison
JavaCC
P
:
M
{
$$
=
$1;
}
void
P()
:
{
int
d1,
d2;
}
{
d1
=
M()
|
P
S
M
{
if
($1
<=
$3
erreur();
(
S()
d2
=
M();
{
if
(d1
<=
d2)
erreur();
$$
=
$3;
}
;
d1
=
d2;
}
)*
}
M
:
C
’x’
D
{
$$
=
$3;
}
;
int
M()
:
{
int
d;
}
{
(
C
"x"
d=D()
)
|
REEL
{
$$
=
0;
}
;
|
(
<REEL>
{
d
=
0;
}
)
{
return
d;
}
}
C
:
REEL
|
/*
vide
*/
;
void
C()
:
{}
{
<REEL>
|
/*
vide
*/
}
D
:
’^’
ENTIER
{
$$
=
$2;
}
int
D()
:
{
int
d;
}
{
(
"^"
<ENTIER>
d
=
Integer.parseInt
(token.image);
)
|
/*
vide
*/
{
$$
=
1;
}
;
|
(
/*
vide
*/
{
d
=
1;
}
)
{
return
d;
}
}
S
:
’+’
|
’-’
;
void
S()
:
{}
{
"+"
|
"-"
}

VI . Analyse s´emantique (3 pts). Dans un compilateur pour un langage orient´e objets, la description c d’une classe comprend en g´en´eral un lien vers la description p de sa classe parente :

p=parente(c) (parente(c)=null si c n’a pas de parente). Le polymorphisme permet de voir un objet de type B comme un objet de type A, a` condition que A soit une classe parente de B. Inversement, le downward cast permet de voir un objet de type A comme un B.

1. On consid`ere l’affectation a = b, ou` a et b sont des objets de type classe ayant pour descrip- teurs respectivement da et db. L’affectation est l´egale si a est d’une classe ancˆetre de celle de b. Donnez la fonction bool conforme (TypeClasse gauche, TypeClasse droite) qui effectue cette v´erification. r´eponse :

On disait que l’affectation est l´egale si a est ancˆetre de b, pas seulement parente. Donc :

TypeClasse

tc

=

droite;

 

while

(tc

!=

null

&&

tc

!=

gauche)

tc

=

parente(tc);

return

tc

!=

null;

2. On consid`ere maintenant l’affectation b = (C) a, ou` dc est le descripteur de la classe C. Quels sont les appels de conforme n´ecessaires pour en v´erifier la validit´e ? r´eponse :

pour (C)

a

:

if

(!conforme

(da,

dc)

pour l’affectation :

erreur

("un

C

n’est

pas

un

descendant

d’un

A");

if (!conforme (db, dc) erreur ("un C n’est pas un descendant d’un B");

Les question suivantes reposent sur l’extrait d’une grammaire G prol de Prolog donn´ee en BNF ´etendue ([ ] = optionnel, { } = 0 ou plusieurs fois). Les questions restent ind´ependantes.

programme → { r`egle }

r`egle terme -> { terme }

terme termeSimple [ . terme ]

termeSimple constante | ident | pr´edicat | tuple | ( terme )

pr´edicat

tuple

constante

;

ident ( terme

{ , terme

{ , terme }

|

} )

< terme

>

<

>

ident | nombre

Exemples (corrects syntaxiquement, mais pas n´ecessairement s´emantiquement) :

a -> p(t.k,1,<i,j>) ; p(a,b) -> q(a,x) r(x,b) ;

VI . Grammaires LL(1) et JavaCC. (1pt + 2 pts)

1. Cette grammaire n’est pas LL(1). Expliquez bri`evement pourquoi. r´eponse :

Diff´erents choix de termeSimple ont ident comme premier. Elle est ambigu¨e car ident peut se r´eduire a` terme ou a` constante qui se r´eduit a` terme. Si on enl`eve cette ambigu¨ıt´e, elle est encore LL(2) a` cause de termeSimplepr´edicat|ident

2. Transformez l`a pour qu’elle soit accept´ee par JavaCC sans conflit LL(1) (inutile de d´efinir les tokens, juste les r`egles de la grammaire) r´eponse :

void

programme()

:

{}

{

(

regle()

)*

}

void

regle()

:

{}

{

terme

"->"

(

terme()

)*

";"

}

void

terme()

:

{}

{

termeSimple

[

"."

terme()

]

}

void

termSimple()

 

:

{}

{

<NBR>

|

ipc()

|

tuple()

 

|

"("

terme()

")"

}

void

ipc()

:

{}

{

<ID>

 

[

"("

termes()

 

")"

]

}

/*

ident,

predicat

ou

constante

*/

void

tuple()

:

{}

{

"<"

 

[

termes()

]

">"

}

termes()

:

{}

{

terme()

(

","

terme()

 

)*

}

VII . Bison. (3 pts)

les d´eclarations de tokens, mais pas leur d´efinition Flex)

r´eponse :

Transformer cette grammaire en format acceptable par Bison (incluant

%token

ID

NBR

FLECHE

%%

programme

:

/*

vide

*/

|

programme

regle

;

 

regle

:

terme

FLECHE

|

regle

terme

;

terme

:

termeSimple

|

termeSimple

’.’

terme

;

termSimple

:

NBR

|

ipc

|

tuple

|

’(’

terme

’)’

;

ipc

:

ID

|

ID

’(’

termes

’)’

;

tuple

:

’<’

termes()

’>’

|

’<’

’>’

;

termes

:

terme

|

termes

’,’

terme

;

VIII . Arbre abstrait. (3 pts) r´eponse :

Donnez (Java ou C) la d´efinition des nœuds de l’arbre abstrait.

struct

terme

{

struct

terme

 

*suiv;

/*

pour

chainer

en

listes

*/

struct

termeSimple

*tsimp;

/*

jamais

NULL

*/

struct

terme

 

*term;

/*

peut

etre

NULL

*/

};

struct

termeSimple

{

enum

GenreTerme

{

cste,

vrbl,

pred,

tuple

}

genre;

 

union

{

 

double

nbr;

/*

si

cste

*/

struct

{

/*

si

autre

*/

 

const

char*

id;

/*

NULL

ssi

tuple

*/

struct

terme

*termes;

/*

NULL

ssi

vrbl

ou

tuple

vide

*/

}

aut;

};

struct

regle

{

struct

regle

*suiv;

struct

terme

*gauche;

struct

terme

*droites;

};

IX . Construction de l’arbre abstrait. (2 pts)

abstrait dans l’une des grammaires (JavaCC ou Bison) que vous avez ´ecrites. r´eponse :

Ajoutez les actions pour construire cet arbre

%{

struct

regle

*arbre;

%}

%union

{

struct

regle

*reg;

struct

termeSimple

*tsi;

struct

terme

*ter;

}

%type<reg>programme

%type<ter>terme

%type<tsi>termeSimple

regles

regle

termes

tuple

stermes

%%

programme

:

regles

 

{

arbre

=

$1;

}

;

regles

:

regle

 

{

$$

=

$1;

}

|

programme

regle

{

$$

=

chainerRegles

($1,

$2)

}

;

regle

:

terme

FLECHE

stermes

{

$$

=

newRegle

($1,

$3);

}

;

stermes

:

terme

 

{

$$

=

$1;

}

|

stermes

terme

{

$$

=

chainerTermes

($1,

$2);

}

;

terme

:

termeSimple

 

{

$$

=

newTerme

($1,

NULL);

}

|

termeSimple

’.’

terme

{

$$

=

newTerme

($1,

$3);

}

;

termeSimple

:

NBR

{

$$

=

newCste

($1);

}

|

ipc

{

$$

=

$1;

}

|

tuple

 

{

$$

=

newAutre

(tuple,

NULL,

$1);

}

|

’(’

terme

’)’

{

$$

=

$2;

}

;

ipc

:

ID

{

$$

=

newAutre

(vrbl,

$1,

NULL);

}

 

|

ID

’(’

termes

’)’

{

$$

=

newAutre

(pred,

$1,

$3);

}

;

tuple

:

’<’

termes()

’>’

{

$$

=

$2;

}

|

’<’

’>’

{

$$

=

NULL;

}

;

termes

:

terme

 

{

$$

=

$1;

}

|

termes

’,’

terme

{

$$

=

chainerTermes

($1,

$3);

}

;