Vous êtes sur la page 1sur 16

GROUP: 4SIQ3

Realisé Par:
Assem Chelli
1

I. Index
I. Index

II. Travail à Réaliser

III. Introduction

A. Transformations de Grammaire
B. Extensions de grammaire :

IV. Conception
A. Génération des quadruplets
B. Schéma des classes

V. Implémentation
A. Routines Sémantique
B. Gestion des erreurs
1. Erreurs Lexical
2. Erreurs Syntaxique
3. Erreurs Sémantique

VI. Conclusion
2

II. Travail à Réaliser :


COMPILATEUR REDUCED-P ASCAL :
Le But de ce TP est de développer un compilateur pour le langage Reduced-Pascal .

Compilateur devra générer une forme intermédiaire sous forme de quadruplets.

Votre Compilateur aura pour entrées des programmes écrits dans le langage Reduced-Pascal.

Si un programme est correct (après les vérifications lexicale, syntaxique,..) un fichier de sortie sera
génère contenant le code intermédiaire sous format quadruplets correspondant au code source donne
en entrée.

Si une erreur se produit aucun fichier de sortie ne sera généré. Pour le signalement des erreurs, deux
stratégies devront être proposées par votre compilateur. La première consiste à s’arrêter à la première
erreur et donner à l’utilisateur un message significatif de cette erreur pour faciliter la correction.

La deuxième stratégie que devra proposer votre compilateur essayera de détecter toutes les erreurs
signalées après la première erreur .Avec cette stratégie, les erreurs signalées âpres la première erreur
.Avec cette stratégie, les erreurs signalées âpres la première erreur peuvent dans certains cas s’avérer
des écritures correctes.

Vous devez utilisez pour ce travail pratique l’outil JavaCC et la plate-forme Eclipse.

JavaCC (java Compiler Compiler) est un générateur de compilation utilisant la méthode LL(1) qui, a partir
de la spécification d’une grammaire et d’un code adéquat.

Génère (si pas d’erreurs), un fichier source écrit en Java .Ce fichier source devra a son tour être compile
en utilisant éclipse (et plug-in adéquat) pour produire l’exécutable du compilateur que vous aurez conçu

Remettre pour chaque TP un rapport détaille, vos programmes sources et un jeu d’essais démontrant
des exemples significatifs du travail réalise
3

I. Introduction :
A. Transformations de Grammaire
 Elimination de récursivité à gauche :
a. Enonce :
énonce ::= <IDENT> X

| entrée

| sortie

| enonce_compose

| enonce_conditionnel

| enonce_iteratif

X ::= affectation

affectation ::= ( array_index )? <ASSIGNOP> expression

B. Extensions de Grammaire
 Enonce_conditionnel
enonce_conditionnel ::= case_of

| if_then_else

case_of ::= <CASE> expression <OF> ( serial_case_statment )* case_statment (


<SEMICOLON> <ELSE> enonce ( <SEMICOLON> )? )? <END>

serial_case_statment ::= case_statment <SEMICOLON>

case_statment ::= constante <COLON> enonce


4

 Enonce itératif :
enonce_iteratif ::= tq

| repeter

| pour

tq ::= <WHILE> expression <DO> enonce

repeter ::= <REPEAT> enonce <UNTIL> expression

pour ::= <FOR> <IDENT> affectation ( <TO> | <DOWNTO> ) expression <DO> enonce

 Goto-label :
partie_declarative ::= ( <LABEL> ( serial_dcllbl )+ )? ...

serial_dcllbl ::= dcllbl <SEMICOLON>

dcllbl ::= ( serial_ident_lbl )* <IDENT>

serial_ident_lbl ::= <IDENT> <COMMA>

goto_label ::= <GOTO> <IDENT>

enonce ::= goto_label

| …

 Déclaration d’un constant :


partie_declarative ::= … ( <CONST> <IDENT> ( <COLON> type )? <E> constante <SEMICOLON> )*…

Tq « <E> »  « = »
5

II. Conception
A. Catégories de quads :
 Branchement Quadruplets:
Mnémoniques
Nom JUMP If
JZ Zéro
JNZ Non zéro
JG Greater
JL Less
JGE Greater or Equal
JLE Less or Equal

Structure:
1 2 3 4
branchement NIL NIL @adresse
Exemple
opération op1 op2 résulte
JGE Nil Nil 15

 Operations Arithmétiques et logiques:


Mnémoniques
Nom fonction
Add Addition
Mul multiplication
Divqq Division
Div Division entier
neg negative
sub soustraction
not Non _logique
or Ou-logique
And Et-logique
xor Ou-exclusif

Structure:
1 2 3 4
opération operand1 operand2 (si existe) résulte
6

Exemple
opération op1 op2 résulte
Add A 5 Tmp1
Or B 1 Tmp2
Not Tmp2 Nil Tmp3

 Autre :
 Mnémoniques
Nom fonction
cmp comparaison
Mov affectation
write Write variable
read Read variable
call Appel d’une procédure
push empiler
pop dépiler


 Structure:
1 2 3 4
fonction spécialise spécialise spécialisé

 Exemple
opération op1 op2 résulte
cmp A B Nil
Mov A Tmp1
Write A
call @proc
push 15
pop Tmp2
7

Schéma des classes :

LexTests:
1.definir les variables et les
methodes pour l'analyse
lexical
2.colorer le code selon les
types des mots Temp :
1.generation
automatic des
variables temporaire
TableQuads:
1.genere le code
intermediare Quad:
1.structure de
quadruplet

MyPascal TableSymbole:
Symbole:
1.stockage les
structure de
identificateurs(symboles) ave
tous les informations symbole
neçessaires
2.detecter les erreurs Parametre:
sémantique
special utilisation dans les
branchement
(ex:goto-label,break...)

Parser classes:
ces classes sont
auto generee par
javacc

Interface class:
1.pour manipulation
visuel

Schéma des classes & rôles


8

III. Implémentation
A. Routines sémantique :

GRAMMAIRE+ ROUTINES EXAMPLE


x=expression_simple() y=oprel() a<b
Expressions z=expression_simple() /*routine1*/
relationnel
//routine1
if (y=="=") inst="je";
if (y=="<") inst="jl"; Num operation op1 op2 result
if (y==">") inst="jg";
if (y=="<=") inst="jle"; 0 cmp a b
if (y==">=") inst="jge";
if (y=="<>") inst="jne"; 1 jl 3

String tmp= NewTemp(); 2 mov 0 tmp0


genereQuad("cmp",x,z,"");
genereQuad(inst,"","", getCourant()+2); 3 jmp 5
genereQuad("mov","0","",tmp);
genereQuad("jmp","","", getCourant()+2);
4 mov 1 tmp0
genereQuad("mov","1","",tmp);

if () then a:=a+1 else a:=a-1;


IF THEN <IF> expression() /*R1*/
<THEN> enonce() /*R2*/ 5 jz 9
ELSE (LOOKAHEAD(2) <ELSE> /*R3*/
enonce() /*R4*/)? 6 add a 1 tmp1
//R1 7 mov tmp1 a
{SaveAdr=genereQuad("jz","","","");}
//R2 8 jmp 11
{
modifyQuad(SaveAdr,4,Tquad.getCourant(); 9 sub a 1 tmp2
}
//R3
10 mov tmp2 a
{
SaveAdr2=genereQuad("jmp","","","");
modifyQuad(SaveAdr,4,getCourant());
}
//R4
{modifyQuad(SaveAdr2,4,getCourant();}
9

<WHILE> /*R1*/ while a<>5 do a:=a+1 ;


WHILE_DO expression()/*R2*/
<DO> enonce() /*R3*/

//R1 Num operation op1 op2 result


{SaveAdr=getCourant();}
//R2
0 cmp a 5
{SaveAdr2=genereQuad("jz","","","");} 1 jne 3
//R3
{genereQuad("jmp","","",SaveAdr); 2 mov 0 tmp0
modifyQuad(SaveAdr2,4,getCourant());
} 3 jmp 5
4 mov 1 tmp0
5 jz 9
6 add a 1 tmp1
7 mov tmp1 a
8 jmp 0
<REPEAT> /*R1*/ enonce() repeat a:=a+1 until a=5;
REPEAT <UNTIL> expression() /*RT2*/
Num operation op1 op2 result
UNTIL
//R1 0 add a 1 tmp0
{SaveAdr= getCourant();} 1 mov tmp0 a
//R2
2 cmp a 5
{ genereQuad("jnz","","",SaveAdr);}
3 je 5
4 mov 0 tmp1
5 jmp 7
6 mov 1 tmp1
7 jnz 0

<FOR> t=<IDENT> affectation(t) for a:=5 downto 0 do write(a);


FOR (s=<TO> | s=<DOWNTO>)/*R1*/
x=expression() /*R2*/ Num operation op1 op2 result
<DO> enonce() /*R3*/

//R1 0 mov 5 a
{SaveAdr= getCourant();}
//R2
{genereQuad("cmp",t,x,""); 1 cmp a 0
SaveAdr2=genereQuad("jz","","","");}
//R3
{if (s=="to") genereQuad("add",t,"1",t); 2 jz 6
else genereQuad("sub",t,"1",t) ;
genereQuad("jmp","","",SaveAdr);
modifyQuad(SaveAdr2,4,getCourant());} 3 write a

4 sub a 1 a

5 jmp 1
10

<PROCEDURE> <IDENT> <SEMICOLON>/*R1*/ procedure proc; var a:integer;


Declare bloc() /*R2*/ begin
procedure //R1 a:=a+1
{SaveAdr=genereQuad("jmp","","",""); } end;
//R2
{adr=NewTemp(); Num operation op1 op2 result
genereQuad("pop","","",adr);
genereQuad("call","","",adr); 0 jmp 5
modifyQuad(SaveAdr,4, getCourant()); }
1 add a 1 tmp0
2 mov tmp0 a
3 pop tmp1
4 call tmp1
<IDENT> /*R1*/
Call proc;
//R1 :@ de proc existe dans table
procedure symboles
{ genereQuad("push","","",getCourant()+2));
5 push 7
genereQuad("call","","",Tsym.getval(t));
6 call 0
}
11

B. Gestion des erreurs


 Erreurs Lexicaux

On peut détecter Ces erreurs Dans l’analyse lexicale :

 Manques et débordement de parenthèses ( ‘(‘ ,‘)’,’[‘,’]’…)


<BRACKETOPEN:"("> { /*routine ; cpt++*/}
| <BRACKETCLOSE:")"> { /*routine ; cpt--*/}

 Les symboles non autorise (ex : $ ,╚,°)

//skip unautorised
//déclarée après tous les tokens
SKIP:
{
<Unautorised:(~["_"])> { /*routine*/ }
}

 Un identificateur de longueur supérieure a 30 caractères


<IDENT:<LETTER> (<LETTER> | <DIGIT> | "_")*> { /*routine*/ }

Remarque :
On peut utiliser analyse lexical pour faire un code avec « High Light »

Ex : <PROGRAM:"program"> { ToHighLight("program","blue","+1","b");}

Exemple :

Analyse Lexical
Code on High Light
error #1:identificateur
1 program test3333333333333 <test33333333333333333333333333333333333> déclarée a
3333333333333333333333$; ligne <1> de longueur <39> supérieure a 30
error #2:Unautorised Symbol <$>
error #3:un débordement de ) a la ligne 5
2 var a:integer; error#4:Excepté ) a la ligne 6
error #5:un débordement par 1 éléments de <begin>
3 begin

4 begin

5 a=((a+2)-1))*(5+6;

6 end;
12

 Erreurs Syntaxique
Comment placer les routines ?
Par exemple :

programme ::= <PROGRAM> <IDENT> <SEMICOLON> bloc <FULLSTOP>

on placer les routine comme l’exemple suivant ,toujours skip a la point-virgule ,point, virgule,
parenthèse ou « end » suivante pour éliminer le décalage enter la grammaire et les « tokens »

int programme()
{

try
{
<PROGRAM> <IDENT> <SEMICOLON>
}
catch (ParseException e)
{
errorSkipTo(SEMICOLON);
}
try {bloc()<FULLSTOP> }
catch (ParseException e)
{ errorSkipTo(FULLSTOP); }
}

 Exemple :
Code on High Light Analyse Syntaxic
1 program test; error #1:
encountree <9>dans ligne '3'et colomne '7'
exeptee:<IDENT>
2
error #2:
3 var a,9,f:integer; encountree <..> dans ligne '4'et colomne '16'
exeptee:<NATURAL>;
4 b:array[..5] of int__eger; error #3:
encountree <1>dans ligne '6' et colomne '6'
5 begin exeptee: < IDENT>;

error #4:
6 read(1);
encountree <+>dans ligne '7'et colomne '18'
exeptee:<SEMICOLON><"[">;
7 while a<5 do a:=a++;
13

 Erreurs sémantique
Dans l’analyse sémantique il faut détecter ces erreurs:

 Ré-déclaration de symboles (variables, constants ,procédures…) ;


<PROCEDURE> t=<IDENT> <SEMICOLON>

{if (TableSym.search(t.image)==true) /*routine d’erreur*/ }

 Utilisation des symboles non déclarée


t=<IDENT> <SEMICOLON>

{if (TableSym.search(t.image)==false) /*routine d’erreur*/ }

 Utilisation un symbole déclaré a un type différent


t=<IDENT> <SEMICOLON>

{if (TableSym.search(t.image)==false)
if (TableSym.verify_type(t,"procedure")==false)
/*routine d’erreur*/
;
}

 Etiquette référencée non définie

 Affection des types différents

Exemple

1 program test; Analyse Sémantique


2 label c; error #1:identificateur <a> existe déjà dans
ligne <3> et ré-déclare dans <3>
3 var a,a:integer; error #2:call for inexistant identificateur
4 begin <b> a la ligne <5>
error #3:l'identificateur <a>déclarée a ligne
5 a:=a+b; 3 est de type variable n'est pas de type
6 a; procedure
error #3:l'étiquette de c n'est pas définie
7 goto c;
8 end.
14

Pour détecter ces erreurs ,il faut déclarer la Table de Symboles

id type type2 Value propriétaire ligne

Variable,
Pour les Pour les
Constante, Value pour
variables et variables La ligne dans la
Programme, constantes,
constantes, locaux (que source (pour
L’Identificateur Adresse pour
Procédure, soyons l’affichage
ex : réel, procédures et
déclarée dans d’erreurs)
label labels
intègre… un procédure)
(étiquette)

 Exemple :
1 program test;
id type type2 Value owner line
2 label etiq;
test program _GLOBAL_ 1
3 const PI=3.14;
etiq label 5 _GLOBAL_ 2
4 var a:integer;
PI constant 3.14 _GLOBAL_ 3
5 procedure proc_A;
a variable integer _GLOBAL_ 4
6 var v:real;
proc_A procedure 0 _GLOBAL_ 5
7 begin

v variable real proc_A 6


8 end;

9 begin

10 a:=a+1;

11 etiq:

12 end.
15

IV. Conclusion
Le réel pascal est trop vaste donc elle est difficile de définir la grammaire
complète même ces routines de détection des erreurs et celle de génération de
code

Dans ce tp,un gestionnaire des erreurs simple est implémenté et il peut


détecter la plupart des erreurs dans un programme pascal..

Un générateur de code intermédiaire est implémenté aussi, un additionnel


module pour colorer le code “highlight” ,et la déclaration multiple de variables
dans les imbrications est assure

Les conflits de types dans l’opération arithmétique et logique


malheureusement n’est pas implémenté car un problème d’organisation des
fonctions récursives.

Et finalement, Grace a ce TP ,j’apprendre beaucoup de choses importante à


propos la compilation avec la méthode descendant récursive .