GROUP: 4SIQ3

Assem Chelli

Realisé Par:

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 quadrupletsB. Schéma des classes

V. Implémentation

A. Routines SémantiqueB. Gestion des erreurs

1. Erreurs Lexical2. Erreurs Syntaxique3. Erreurs Sémantique

VI. Conclusion

2

II. Travail à Réaliser :

COMPILATEUR REDUCED-PASCAL :

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, deuxstratégies devront être proposées par votre compilateur. La première consiste à s’arrêter à la premièreerreur 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émontrantdes 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_conditionnelenonce_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 IfJZ ZéroJNZ Non zéroJG GreaterJL LessJGE Greater or EqualJLE Less or Equal

Structure:

1 2 3 4branchement NIL NIL @adresse

Exemple

opération op1 op2 résulteJGE Nil Nil 15

Operations Arithmétiques et logiques:

Mnémoniques

Nom fonctionAdd AdditionMul multiplicationDivqq Division Div Division entierneg negativesub soustractionnot Non _logiqueor Ou-logiqueAnd Et-logiquexor Ou-exclusif

Structure:

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

6

Exemple

opération op1 op2 résulteAdd A 5 Tmp1

Or B 1 Tmp2

Not Tmp2 Nil Tmp3

Autre :

Mnémoniques

Nom fonctioncmp comparaisonMov affectationwrite Write variableread Read variablecall Appel d’une procédurepush empilerpop dépiler

Structure:

1 2 3 4fonction spécialise spécialise spécialisé

Exemple

opération op1 op2 résultecmp A B Nil

Mov A Tmp1

Write A

call @proc

push 15

pop Tmp2

7

Schéma des classes :

Schéma des classes & rôles

MyPascal

LexTests:

1.definir les variables et les methodes pour l'analyse

lexical

2.colorer le code selon les types des mots

TableQuads:1.genere le code

intermediare

Temp :1.generation

automatic des variables temporaire

Quad:1.structure de

quadruplet

TableSymbole:1.stockage les

identificateurs(symboles) ave tous les informations

neçessaires

2.detecter les erreurs sémantique

Symbole:structure de

symbole

Parametre:

special utilisation dans les branchement

(ex:goto-label,break...)

Parser classes:ces classes sont

auto generee par javacc

Interface class:1.pour manipulation

visuel

8

III. Implémentation

A. Routines sémantique :

GRAMMAIRE+ ROUTINES EXAMPLE

Expressions relationnel

x=expression_simple() y=oprel() z=expression_simple() /*routine1*/

//routine1 if (y=="=") inst="je"; if (y=="<") inst="jl"; if (y==">") inst="jg"; if (y=="<=") inst="jle"; if (y==">=") inst="jge"; if (y=="<>") inst="jne";

String tmp= NewTemp();genereQuad("cmp",x,z,"");genereQuad(inst,"","", getCourant()+2); genereQuad("mov","0","",tmp);genereQuad("jmp","","", getCourant()+2);genereQuad("mov","1","",tmp);

Num operation op1 op2 result

0 cmp a b

1 jl 3

2 mov 0 tmp0

3 jmp 5

4 mov 1 tmp0

a<b

IF THEN ELSE

<IF> expression() /*R1*/<THEN> enonce() /*R2*/ (LOOKAHEAD(2) <ELSE> /*R3*/enonce() /*R4*/)?

//R1{SaveAdr=genereQuad("jz","","","");}//R2{ modifyQuad(SaveAdr,4,Tquad.getCourant();}//R3{SaveAdr2=genereQuad("jmp","","","");modifyQuad(SaveAdr,4,getCourant());} //R4{modifyQuad(SaveAdr2,4,getCourant();}

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

5 jz 9

6 add a 1 tmp1

7 mov tmp1 a

8 jmp 11

9 sub a 1 tmp2

10 mov tmp2 a

9

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

//R1{SaveAdr=getCourant();}//R2{SaveAdr2=genereQuad("jz","","","");}//R3{genereQuad("jmp","","",SaveAdr); modifyQuad(SaveAdr2,4,getCourant());}

while a<>5 do a:=a+1 ;

Num operation op1 op2 result

0 cmp a 5

1 jne 3

2 mov 0 tmp0

3 jmp 5

4 mov 1 tmp0

5 jz 9

6 add a 1 tmp1

7 mov tmp1 a

8 jmp 0

REPEAT UNTIL

<REPEAT> /*R1*/ enonce() <UNTIL> expression() /*RT2*/

//R1

{SaveAdr= getCourant();}//R2

{ genereQuad("jnz","","",SaveAdr);}

repeat a:=a+1 until a=5;

Num operation op1 op2 result

0 add a 1 tmp0

1 mov tmp0 a

2 cmp a 5

3 je 5

4 mov 0 tmp1

5 jmp 7

6 mov 1 tmp1

7 jnz 0

FOR<FOR> t=<IDENT> affectation(t) (s=<TO> | s=<DOWNTO>)/*R1*/x=expression() /*R2*/<DO> enonce() /*R3*/

//R1{SaveAdr= getCourant();}//R2{genereQuad("cmp",t,x,"");SaveAdr2=genereQuad("jz","","","");}//R3{if (s=="to") genereQuad("add",t,"1",t);else genereQuad("sub",t,"1",t) ;genereQuad("jmp","","",SaveAdr);

modifyQuad(SaveAdr2,4,getCourant());}

for a:=5 downto 0 do write(a);

Num operation op1 op2 result

0 mov 5 a

1 cmp a 0

2 jz 6

3 write a

4 sub a 1 a

5 jmp 1

10

Declare procedure

<PROCEDURE> <IDENT> <SEMICOLON>/*R1*/bloc() /*R2*/

//R1{SaveAdr=genereQuad("jmp","","",""); }//R2{adr=NewTemp();genereQuad("pop","","",adr);genereQuad("call","","",adr); modifyQuad(SaveAdr,4, getCourant()); }

procedure proc; var a:integer;begina:=a+1end;

Num operation op1 op2 result

0 jmp 5

1 add a 1 tmp0

2 mov tmp0 a

3 pop tmp1

4 call tmp1

Call procedure

<IDENT> /*R1*/

//R1 :@ de proc existe dans table symboles{ genereQuad("push","","",getCourant()+2));

genereQuad("call","","",Tsym.getval(t));

}

proc;

5 push 7

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 :

Code on High Light

1 program test33333333333333333333333333333333333$;

2 var a:integer;

3 begin

4 begin

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

6 end;

Analyse Lexical

error #1:identificateur <test33333333333333333333333333333333333> déclarée a ligne <1> de longueur <39> supérieure a 30 error #2:Unautorised Symbol <$> error #3:un débordement de ) a la ligne 5error#4:Excepté ) a la ligne 6error #5:un débordement par 1 éléments de <begin>

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

1 program test;

2

3 var a,9,f:integer;

4 b:array[..5] of int__eger;

5 begin

6 read(1);

7 while a<5 do a:=a++;

Analyse Syntaxicerror #1:encountree <9>dans ligne '3'et colomne '7'exeptee:<IDENT>

error #2:encountree <..> dans ligne '4'et colomne '16'exeptee:<NATURAL>;

error #3:encountree <1>dans ligne '6' et colomne '6'exeptee: < IDENT>;

error #4:encountree <+>dans ligne '7'et colomne '18'exeptee:<SEMICOLON><"[">;

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éet=<IDENT> <SEMICOLON>

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

Utilisation un symbole déclaré a un type différentt=<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;

2 label c;

3 var a,a:integer;

4 begin

5 a:=a+b;

6 a;

7 goto c;

8 end.

Analyse Sémantiqueerror #1:identificateur <a> existe déjà dans ligne <3> et ré-déclare dans <3>error #2:call for inexistant identificateur<b> a la ligne <5>error #3:l'identificateur <a>déclarée a ligne 3 est de type variable n'est pas de type procedureerror #3:l'étiquette de c n'est pas définie

14

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

id type type2 Value propriétaire ligne

L’Identificateur

Variable, Constante,

Programme,

Procédure,

label (étiquette)

Pour les variables et constantes,

ex : réel,

intègre…

Value pour constantes,

Adresse pour procédures et

labels

Pour les variables

locaux (que soyons

déclarée dans un procédure)

La ligne dans lasource (pour

l’affichage d’erreurs)

Exemple :

1 program test;

2 label etiq;

3 const PI=3.14;

4 var a:integer;

5 procedure proc_A;

6 var v:real;

7 begin

8 end;

9 begin

10 a:=a+1;

11 etiq:

12 end.

id type type2 Value owner line

test program _GLOBAL_ 1

etiq label 5 _GLOBAL_ 2

PI constant 3.14 _GLOBAL_ 3

a variable integer _GLOBAL_ 4

proc_A procedure 0 _GLOBAL_ 5

v variable real proc_A 6

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 logiquemalheureusement 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 .