le sujet du partiel de mars 2013 - Verimag

Licence Sciences et Technologie UJF 

Parcours Informatique UE INF246 

Durée : 1h30 - Tous documents autorisés 

Introduction 

Devoir Surveillé du 8 mars 2013 

On s’intéresse à un langage de description de document, où un document est une séquence de chapitre et 

chaque chapitre est une séquence de paragraphe. Ce langage sera appelé le langage Doc dans la suite. On donne 

ci-dessous un exemple de document D décrit dans ce langage : 

chap "introduction" (par "objectif"; par "approche";); 

chap "le probleme" (); 

chap "solution" (par "description"; par "formalisation";); 

chap "conclusion" (); 

On constate sur cet exemple que ce langage est formé à partir de deux opérateurs : 

– l’opérateur chap, qui a pour opérandes le titre du chapitre et une séquence de paragraphe (entre parenthèses) ; 

– l’opérateur par qui a pour opérande le titre du paragraphe. 

L’objectif de ce travail est d’écrire un programme sur le même modèle que ce qui a été fait en TD. Ce programme 

prendra donc en entrée une expression lue au clavier décrivant un document et effectuera : 

– une analyse lexicale du langage : question 1 ; 

– une analyse syntaxique, avec construction d’un arbre abstrait : questions 2 et 3 ; 

– un traitement effectué sur l’arbre abstrait : question 4. 

Seules les questions 2 et 3 sont liées entre-elles, et peuvent être résolues simultanément si vous le souhaitez. Les 

autres questions sont indépendantes et peuvent être traités dans n’importe quel ordre. 

Question 1 : analyse lexicale 

Les lexèmes du langage sont les suivants : 

– CHAP, représente le mot-clé chap ; 

– PAR, représente le mot-clé par ; 

– PVIRG, représente le caractère ; (un point-virgule) ; 

– PARO, représente le caractère ( ; 

– PARF, représente le caractère ) ; 

– TITRE, représente une chaîne de caractères entre guillemets (par exemple "introduction") ; 

– FIN_SEQ, représente la fin de la séquence lue au clavier. 

Dessinez un automate de reconnaissance de ces lexèmes. Cet automate lit en entrée une séquence de caractères 

et il atteint un état final lorsqu’un lexème a été reconnu. Les transitions seront étiquetées uniquement par le 

caractère courant et par l’indication Av si et seulement si on doit lire le caractère suivant lors de l’exécution de 

cette transition. 

Les caractères séparateurs sont “espace” et “fin ligne”, et on ne fera pas apparaitre le traitement des erreurs 

lexicales. 

1

Question 2 : analyse syntaxique 

La grammaire (sous forme LL(1)) du langage Doc est la suivante : 

Doc → SeqChap FIN_SEQ 

SeqChap → CHAP TITRE PARO SeqP ar PARF PVIRG SeqChap 

SeqChap → ε 

SeqP ar → PAR TITRE PVIRG SeqP ar 

SeqP ar → ε 

En utilisant les primitives de machine_lexemes.ads, fournies en Annexe A, écrivez le corps de la procédure 

analyser spécifiée ci-dessous. Vous pouvez écrire des procédures auxilliaires (comme Req_Doc, Req_SeqChap et 

Req_SeqPar). 

procedure analyser ; 

-- e.i. : indifferent 

-- e.f. : une sequence de lexemes a ete lue, l’exception Erreur_Syntaxique 

-- est levee si elle ne respecte pas la grammaire Doc 

Question 3 : construction d’un arbre abstrait 

(la réponse à cette question peut être groupée avec celle de la question 2) 

On donne à titre d’exemple sur la Figure 1 l’arbre abstrait correspondant à l’expression D donnée en introduction 

: 

CHAP 

TITRE PVIRG 

"introduction" 

TITRE 

PAR 

PVIRG 

PVIRG 

PAR 

TITRE 

"approche" 

CHAP 

TITRE 

"objectifs" "le probleme" 

PVIRG 

CHAP 

PVIRG 

TITRE PVIRG 

"solution" 

TITRE 

PAR 

"description" 

PAR 

TITRE 

"formalisation" 

Figure 1 – Arbre abstrait de l’expression D 

PVIRG 

PVIRG 

CHAP 

TITRE 

"conclusion" 

Complétez le code ADA de la question 2 pour que la procédure analyser fournisse en paramètre résultat l’arbre 

abstrait correspondant à l’expression lue (lorsque cette expresion ne contient pas d’erreurs) comme spécifié ciaprès 

: 

2

procedure analyser (A : out Ast) ; 


-- e.f. : une sequence de lexemes a ete lue, l’exception Erreur_Syntaxique 

-- est levee si elle ne respecte pas la grammaire Doc, sinon A 

-- contient l’arbre abstrait de l’expression correspondante 

On pourra utiliser 1 les types et primitives des paquetages arbre_abstrait.ads et arbre_abstrait-construction.ads 

fournis en Annexes B et C. 

Question 4 : création d’une table des matières 

En effectuant un parcours de l’arbre abstrait d’une expression du langage Doc, écrivez le corps de la procédure 

table_matieres spécifiée ci-dessous. On pourra écrire une procédure récursive, et on pourra utiliser les procédures 

Put pour écrire des entiers et des caractères, et Put_Line pour écrire des chaînes de caractères terminées 

par un fin-de-ligne. On supposera que le type Ast n’est pas “privé” dans cette fonction. 

procedure table_matieres (A : in Ast) ; 


-- e.f. : la table des matieres correspondant a l’arbre abstrait A est affichee. 

On donne à titre d’exemple la table des matières de l’expression D correspondant à l’arbre abstrait de la Figure 1. 

1. "introduction" 

1.1 "objectif" 

1.2 "approche" 

2. "probleme" 

3. "solution" 

3.1 description" 

3.2 "formalisation" 

4. "conclusion" 

Annexe A : le paquetage machine_lexemes.ads 

package machine_lexemes is 

Erreur_Lexicale : exception ; 

type Nature_Lexeme is ( 

CHAP, -- le mot-cle chap 

PAR, -- le mot-cle par 

PVIRG, -- ; 

PARO, -- ( 

PARF, -- ) 

TITRE, -- chaine de caracteres entre guillemets 

FIN_SEQ -- lexeme de fin de sequence 

); 

type Pointeur_Chaine is access String; 

1. sans les écrire 

3

type Lexeme is record 

nature : Nature_Lexeme; -- nature du lexeme 

chaine : Pointeur_Chaine; -- chaine de caracteres 

end record; 

procedure demarrer; 


-- e.f. : la sequence de lexemes est lue au clavier 

-- fin_de_sequence lexeme_courant.nature = FIN_SEQ 

-- (non fin_de_sequence) => lexeme courant est le premier 

-- lexeme de la sequence 

procedure demarrer(nom_fichier : String); 


-- e.f. : la sequence de lexemes est lue dans le fichier designe par 

-- nom_fichier 

-- fin_de_sequence lexeme_courant.nature = FIN_SEQ 

-- (non fin_de_sequence) => lexeme courant est le premier 

-- lexeme de la sequence 

-- l’exception Erreur_Lexicale est levee en cas d’erreur 

procedure avancer; 

-- pre-condition : la machine sequentielle est demarree 

-- e.i. : on pose i = rang du lexeme_courant : 

-- (non fin_de_sequence) 

-- et (non lexeme_courant.nature = FIN_SEQ) 

-- e.f. : fin_de_sequence lexeme_courant.nature = FIN_SEQ 

-- (non fin_de_sequence) => lexeme_courant est le lexeme i+1 

-- l’exception Erreur_Lexicale est levee en cas d’erreur 

function lexeme_courant return Lexeme; 


-- lexeme_courant est : 

-- . le pseudo lexeme FIN_SEQ si fin_de_sequence 

-- . le lexeme de rang i sinon 

function fin_de_sequence return Boolean; 


-- fin_de_sequence vaut : 

-- . vrai si tous les lexemes de la sequence ont ete reconnus 

-- . faux sinon 

procedure arreter; 

-- e.i. : la machine sequentielle est demarree 

-- e.f. : la machine sequentielle est arretee 

end machine_lexemes; 

4

Annexe B : le paquetage arbre_abstrait.ads 

package Arbre_Abstrait is 

type Ast is private; 

type TypeAst is (PVIRG, CHAP, PAR, TITRE); 

private 

type NoeudAst; 

type Ast is access NoeudAst; 

type NoeudAst is record 

nature : TypeAst; 

gauche, droite : Ast; 

chaine : Pointeur_Chaine; -- lorsque la nature est TITRE 

end record; 

end Arbre_Abstrait; 

Annexe C : le paquetage arbre_abstrait-construction.ads 

package Arbre_Abstrait.Construction is 

--------------------------------------------------------------------procedure 

creer_PVIRG (fils_gauche, fils_droit : Ast; A : out Ast); 

-- cree un noeud PVIRG 

--------------------------------------------------------------------- 


creer_CHAP (fils_gauche, fils_droit : Ast; A : out Ast); 

-- cree un noeud CHAP 

--------------------------------------------------------------------- 


creer_PAR (fils_gauche : Ast; A : out Ast); 

-- cree un noeud PAR 

--------------------------------------------------------------------- 


creer_TITRE (chaine_titre : Pointeur_Chaine ; A : out Ast); 

-- cree une feuille de nature TITRE et de chaine chaine_titre 

--------------------------------------------------------------------- 

end Arbre_Abstrait.Construction; 

5

le sujet du partiel de mars 2013 - Verimag

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?