Ministère de l’Enseignement Supérieur et de la Recherche

Scientifique

university de Hassiba ben bouali - Chlef

Faculté des Sciences Exactes et Informatique
Département d’informatique

Traveux Pratique
spécialité Ingenierie Logiciel
par
BOUCHAKOUR ahmed oussama && BERROUDJI Soufyane

Descente récursive pour

l’évaluation et génération d’une
forme intermédiaire d’une
expression arithmétique

Responsable du module : [Link] Nassima

année universitaire 2021/2022
 Introduction générale
Compilateur c’est une programme qui prend le fichier source encrant en langage haut niveaux par
exemple ci ce langage utilisant TP c’est langage C , après sa sera conversion dans un bas niveaux
— Analyse lexicale du texte de code ficher source prend les unités lexicaux bien sur il va
classifier les unité lexicaux non utiliser comme les blancs et commentaire ET unité lexicaux
détecter par expression régulière De ce TP LA utilisant outil LEX sinon signaler les avec
GESTION ERREUR
— Analyse syntaxique phase consiste a regrouper les unités lexicale du programme source en
structures grammaticale De ce TP LA vérifie si un expression arithmétique est correctement
écrit selon la grammaire qui spécifier la structure syntaxique du langage C par outil yacc sinon
signaler les avec GESTION ERREUR
— Analyse Sémantique cette étape base sure Analyse syntaxique correcte , et vérifier deux
champs importante TYPE et VALEUR si vérification successive alors alors implémenter les
action Sémantique C code en YACC de ce TP LA ce type expression arithmétique c’est
séquence vérifier si type flottant et valeur flottant alors la résultat sa donne nombre flottant
sinon signaler les avec GESTION ERREUR
— Code intermédiaire ou bien trois adresse de cette Patrie final de ce TP la cette phase conver-
sion code fichier source vers fichier contient code trois adresse équivalent cette conversation la
machine aimes cette fichier forme intermédiaire et comprend bien et ce TP LA générer trois
adresse et instancier quadruple et triple
— Gestion des erreurs
1. Erreurs lexicales (caractères interdits).
2. Erreurs syntaxiques (règles structurelles non respectées).
3. Erreurs sémantiques (incohérence des opérations : contrôle statique).
4. Diverses récupérations possibles, selon la finalité du compilateur : • arrêt à la première
erreur ;resynchronisation sur la prochaine construction correcte ; tentatives de correction
Ce TP la demande l’appliquer les notion étudier de le module compilation , il va traiter expression
arithmétique donné par un ficher ou par commende flux du caractères entrée et Signaler les erreur si
trouver sinon appliquant l’analyse Sémantique et sortie le résultat après sa générer code intermédiaire
trois adresse instancier sa quadruple et triple Utilisant les outil LEX et YACC
Table des matières

1 Conception et présentation du Partie A,B 1

1.1 introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
1.2 Présentation . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
1.3 Explication de code partie A,B . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Conception et présentation du Partie C 5

2.1 Flash-back . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5
2.2 Introduction . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.3 Présentation et explication du code source de Partie C . . . . . . . . . . . . . . . . . 8
2.3.1 Truc naissaire . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9

3 Realisation Implémentation du PROJET 13

3.1 Code Source de Projet de TP . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.1 Code source LEX . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 13
3.1.2 Code source YACC . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
3.2 Capture d’ecrant montre d’execution . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

Bibliographie 38
Table des figures

1.1 Illustration : Strucure d’un compilateur . . . . . . . . . . . . . . . . . . . . . . . . . . 1

1.2 Illustration : Couplage LEX and Yacc avec C language . . . . . . . . . . . . . . . . . 2
1.3 Illustration : Arbre decoré calcule expression arithmitique . . . . . . . . . . . . . . . . 3

2.1 Illustration : Structure de programmation YACC . . . . . . . . . . . . . . . . . . . . 5

2.2 Illustration : Communication entre LEX and YACC . . . . . . . . . . . . . . . . . . . 6
2.3 Illustration : Phase Sémentic DÉCLARE/RÉDUCTION . . . . . . . . . . . . . . . . 7
2.4 Illustration : Genration code intermidiare . . . . . . . . . . . . . . . . . . . . . . . . . 8
2.5 Illustration : Strucure de donne dependant realise instruction Structure QUAD . . . . 9
2.6 Illustration : Tableuax quadruple expression arithmitique . . . . . . . . . . . . . . . . 10
2.7 Illustration : Etape remplire tableuax getGrammerExp[20][20] . . . . . . . . . . . . . 10
2.8 Illustration : Etape remplire generatet ac < valeur, sio ccupe > . . . . . . . . . . . . . . 11
2.9 Illustration : l’alogorithme simule realiser tableaux quedruple expression arithmitique 12

3.1 Capture Ecrant 1 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31

3.2 Capture Ecrant 2 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
3.3 Capture Ecrant 3 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
3.4 Capture Ecrant 4] . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
3.5 Capture Ecrant 5 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
3.6 Capture Ecrant 6 . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
Chapitre 1

Conception et présentation du Partie A,B

1.1 introduction
On a commence par les notion fondamenteaux pour comprendre caractéristique de ce rapport de
TP la

Figure 1.1 – Illustration : Strucure d’un compilateur

— LEX c’est un outil de programmation par C correspondant phase Analyse lexicale diviser
expression arithmétique entrée par unités lexicaux avec utilise expression régulière importance
2 Chapitre 1. Conception et présentation du Partie A,B

prends seul valide et communiquer avec couplage avec YACC utilisation retourner token par
function yylval() , lance cette analyseur syntaxique utilise fonction yylex()
— Yacc (Yet Another Compiler Compiler) est un programme destiné à compiler une gram-
maire du type LALR(1) et à produire le texte source d’un analyseur syntaxique du langage
engendré par cette grammaire.
Dans un partie A et B Il ce développe l’analyseur syntaxique après sa analyseur lexicale utilise
expression régulière matcher l’ensemble unités lexicaux si prend valide alors retourner TOKENS
valeur vers l’analyseur syntaxique si suite de TOKENS respecter séquence de grammaire alors implé-
menter action de calcule soit [/,* ;+,-],le question c’est le expression arithmétique composé suite d’un
l’ordre opération importance [(,/,*,+,-] comment yacc ou le phase syntaxique choisir supérieur l’ordre
opération importance et solution le problème DÉCLARE/RÉDUCTION ? Et comment sauvegarder
précédant(LAST) valeur de résultat temporaire et utilise prochaine l’ordre opération importance ?
Et comment réalise final résultat et afficher dans fenêtre de commende ? Si scenario lexicale ou syn-
taxique non respecter alors signaler par des message significatifs mais comment faire sa sur code LEX
et YACC ?

Figure 1.2 – Illustration : Couplage LEX and Yacc avec C language

1.2 Présentation
Le expression arithmétique en entrée directement ligne de commende ou a partir d’un fichier
d’entrée et applique sa processus déjà parler mais l’expression arithmétique compose suite l’ordre
opération importance [(,/,*,+,-] comment choisie et résoudre le problème DÉCLARE/RÉDUCTION
décroissante alors c’est le moment utilise le mot réserver sur YACC s’appelle associativité gauche
%left avec l’ordre par exemple : a + b ∗ c + d/f = a + (b ∗ c) + (d/f )
1.3. Explication de code partie A,B 3

1. %left ( )
2. %left / ∗
3. %left + −
l va obtenir solution d’erreur DÉCLARE/RÉDUCTION par gestion d’erreur Mais n’est pas
suffisant il y a surpris autre problème c’est que le sauvegarder résultat temporaire après matcher
unité de grammaire opération détecter d’un parti expression arithmétique et réutilisation pour calcule
prochaine unité de grammaire opération détecter récursivement , malheureusement sur yacc autre
mot réserver Le $$ sauvegarder résultat temporaire et rentabilisable avec $1 ou $2 calcule avec
recusive descendante et générer résultat résultat final

Figure 1.3 – Illustration : Arbre decoré calcule expression arithmitique

La finition du parie a,b tout le lecteurs sa pense sa MAIS si devisions par zéro sa bloque le processus
analyse Sémantique il doit affiche avec gestion l’erreur alors l’ajoute sur unité détecter E/E condition
le décision si($3 == 0) alors yyerror(gestion erreur : diviser par zéro)) sinon
calcule $$ = $1+$3 et contenu le processus de calcule

1.3 Explication de code partie A,B

utilisateur de fenêtre du commende entrée expression arithmétique de la syntaxique : l lettre
= expression_arithmétique segmenter la chaîné entrée de principe l’analyseur lexicale utlise
4 Chapitre 1. Conception et présentation du Partie A,B

expression régulière et LEX communiquer avec YACC ou autre mot la phase

l’analyse syntaxique et sémantique par yylval chaque unité lexicaux détecter et calcule le résultat
temporaire apres sa résultat final par implémenter l’action C$$ = $1 + $3 si non syntaxiquement
correcte alors l’appel gestion d’erreur yyerror(msg)
les composant principe les Grammaire <T,N,P>
— T les terminaux sont valeur numéro flottant
— N non terminaux réduction avec la façon récursive vers les terminaux
— P liste de parie grammaire possible détecter
Les mot réserver sur la phase sémantique sur YACC
— %union liste de type de base accepter prend valeur detecter avec analyseur sémantique de
code TP La soit la valeurs détecter de type entier ou flottant si non respecte le type acceptable
alors l’appel gestion d’erreur yyerror(msg)
— %type <expression> E le opération DÉCLARE/RÉDUCTION Le E se trouve le termi-
naux de type expression sa compose de lise de type%union
Si détecter l’opération [/,*,+,-] alors calcule le résultat temporaire implémenter l’action C {$$ =
$1 + $3 } si détecter valeur zéro sur l’opération division alors affiche yyerror(msg) , et sauvegarde
opération ou valeur de type flottant vers getGrammerExp[20][20] , le fonction réserver par le
langage C strcpy(char *a,char *b) copie la chine a vers b mais a et b c’est le mémé structure
Chapitre 2

Conception et présentation du Partie C

2.1 Flash-back
l’expression arithmétique entrée passer première phase analyseur lexicale que segmente chaîne
de char a plusieurs unité lexicaux respecte soit utilisable ou non si non utilisable comme blancs
alors sauter si utilisable alors communiquer avec analyseur syntaxique si l’ensemble unité lexicaux
respecter le grammaire de l’expression arithmétique déjà déclarer chaque unité respecter alors travers
a analyseur Sémantique alors calcule avec l’action C code prend résultât temporaire récursivement
et obtenir résultat final et afficher dans un fenêtre de commende

Figure 2.1 – Illustration : Structure de programmation YACC

6 Chapitre 2. Conception et présentation du Partie C

Figure 2.2 – Illustration : Communication entre LEX and YACC

On a expression arithmitique : a ∗ (b + c) − d/e

1. (b + c) => Unité 1

2. a∗Unité 1= Sa donne => Unité 2

3. d/e = Sa donne => Unité 3

4. unité 2 – unité 3 =Sa donne=>Unité 4

chaque u[1„4] il va test grammaticaux si juste alors calcule u1 avec méthode DÉCLARE/RÉDUCTION
et prends résultat temporaire et appliqua la façon récursive dans u2,u3,u4 et obtenir résultat finalité
U4
Code intermédiaire ou bien trois adresse de cette Patrie final de ce TP la cette phase conversion
code fichier source vers fichier contient code trois adresse équivalent cette conversation la machine
aimes cette fichier forme intermédiaire et comprend bien et ce TP LA générer trois adresse et ins-
tancier quadruple et triple
2.1. Flash-back 7

Figure 2.3 – Illustration : Phase Sémentic DÉCLARE/RÉDUCTION

8 Chapitre 2. Conception et présentation du Partie C

2.2 Introduction
Le Forme intermédiaire c’est la phase après l’analyse Sémantique correct code l’origine conver-
sation vers code machine appliqua principe trois adresse langage générant externe quadruple et
triple,chaque instruction code trois adresse CTA (nombre instruction, opération ,opérant 1, opérant
2,résultat ou destination), destination = opérant 1 opération opérant 2
— Opération c’est unbranchement changer comportement d’ordre suite d’un l’ordre propriété
variable temporaire ou résultat temporaire expression arithmétique donné complètement c’est
la décision
— exemple : 3 + 4/5 ∗ 6
1. T 0 = 4/5
2. T 1 = T 0 ∗ 6
3. T 2 = 3 + T 1
Mais le grands problème c’est que va simuler le code avec programmation par yacc ? quadruple c’est
instance code trois adresse utlise variable temporaire si utiliser alors je doit élimine

Figure 2.4 – Illustration : Genration code intermidiare

2.3 Présentation et explication du code source de Partie C

le problème obtenir de flash-back c’est reconfiguration le valeur temporaire Tn pour generer les
instructions code trois adresse
2.3. Présentation et explication du code source de Partie C 9

2.3.1 Truc naissaire

ona les rôle du truc suivant va utiliser sur le code
— le Variable temporaire le fête utilise il doit éliminer utilisation alors mort
— instruction final obliger utiliser variable temporaire d’instruction précédant
— soit valeur appartient {numéro,temporaires} appliqua rôle(1) alors on code ajoute le champs
si_occupe type entier va tester occupe déjà utiliser alors sa valeur c’est {1} doit élimine
sinon {0}
— structure de donner de chaque instruction strucure quad

Figure 2.5 – Illustration : Strucure de donne dependant realise instruction Structure QUAD

Alors sauvegarder instruction code trois adresse par fonction addtotable( operand1, operand2,
operator) retourner résulta soit temporaire ou final
Tinstrucion[1,n] : tableaux d’instruction (#) composer quatre champs char operand1[1][20] ; char
operand2[1][20] ;char operator[1][20] ;char result[1][20] ; champs result prend valeur temporaires , le
champs operand1, operand2 prends ses valeur{numéro,temporaires}
Exemple :15 + 8 ∗ 9 + 6 ∗ 5 + 3passage gauche vers droite
10 Chapitre 2. Conception et présentation du Partie C

Figure 2.6 – Illustration : Tableuax quadruple expression arithmitique

char getGrammerExp[20][20] : tableaux qui garder les valeur obtenir yacc passage l’analyse sé-
mantique clac : calcule par operation choisir par associativité gauche chaque détecter deux opération
et après implémenter sauvegarde les valeurs et les opération avec action C de grammaire correspon-
dant

Figure 2.7 – Illustration : Etape remplire tableuax getGrammerExp[20][20]

2.3. Présentation et explication du code source de Partie C 11

NOTE : après chaque calcule [*,/,+,-] il y a instruction code trois adresse alors variable temporaire

Figure 2.8 – Illustration : Etape remplire generatet ac < valeur, sio ccupe >

Passage du tableaux getGrammerExp[20][20] et prends valeur vers tableaux generate_tac valeur

égal numéro et si_occupe égal 0 si détecter Calcule (/,*,+,-) alors prends c’est cas, char ope-
rand1[1][20] ;char operand2[1][20] ;char operator[1][20] ;char result[1][20] ; le champs véritable la table
trois adresse placer avec char* addtotable(char a[1][20], char b[1][20], char o[1][20]) dans un struc-
ture struct expr arr[20] ; a : operand1,b : operand2 , o : operator le valeur prends avec le tableaux
suivant :
— i : indice courant sur le tableaux generate_tac<valeur,si_occupe>
— maj : mise a jour la valeurs courant
— C(i) : fonction cherche se trouve la case si_occupe qui prendre la valeur 0 passage dans
intervalle la case 0 vers case i :indice
— retourner résultat résultat = TN avec fontion char* addtotable(char a[1][20], char b[1][20],
char o[1][20]) ; vers struct expr arr[20] tableaux code trois adresse
12 Chapitre 2. Conception et présentation du Partie C

Figure 2.9 – Illustration : l’alogorithme simule realiser tableaux quedruple expression arithmitique

Alors résumer passage dans un getGrammerExp[20][20] et placer valeur de type flottant vers
generate_tac<valeur = flottant ,si_occupe = 0> si détecter opération alors
1. appel fonction char* addtotable l’ajout une case instruction sa prends quatre champs ope-
rand1 , operand2 , operator
2. généré le résultat temporaire vers case char result[1][20]
3. retourner T n variable résultat temporaire
4. l’ajoute la case du l’indice courant vers le tableaux avec generate_tac l’algorithme déjà vu
sur le tableaux
Les truc de façon affichage le contenu struct expr arr[20] sur format tableaux sur fenêtre de commende
soit la façon quadruple ou triple avec l’appel fonction drawTable() ,drawTableTriblet() code
source
Chapitre 3

Realisation Implémentation du PROJET

3.1 Code Source de Projet de TP

3.1.1 Code source LEX
int main() {
%{
/* Definition section */
#include <stdio.h>
#include "[Link].h"

void echo(char *lex_cat) {

fprintf(stderr,"[%s:%s]", lex_cat, yytext);
}
void echonl() {
fprintf(stderr,"[\\n]\n");
}

void PutValEntier() {
sscanf( yytext, "%d", &[Link] );
}

void PutValFlottant() {
sscanf( yytext, "%f", &[Link] );
}
void putValChaineDeChar(){
sscanf( yytext, "%s", [Link] );
}
%}

/* Rule Section */
14 Chapitre 3. Realisation Implémentation du PROJET

/*================================================================
Genere Expression reguliere
{DIGIT}+\.{DIGIT}*,{DIGIT}*\.{DIGIT}+: nombre reel
{DIGIT}+ : nombre entier
[\t],[\n]:n'est pas importante
PutValEntier();PutValFlottant();|communuquer avec yacc utlise yylval
chaque en cas besion nouvelle l'unite lexiceaux
=================================================================*/
DIGIT [0-9]
%%
{DIGIT}+ { echo("ENTIER"); PutValEntier(); return ENTIER ; }
{DIGIT}+\.{DIGIT}* |
{DIGIT}*\.{DIGIT}+ { echo("REEL"); PutValFlottant(); return FLOTTANT ; }
[-+*/%()] { echo("Tokens"); return yytext[0]; }
[a-z]+ { echo("CHAINE");putValChaineDeChar();return LETTER;}
[\t] ;

[\n] return 0;

. return yytext[0];

%%
/*pour genere de fichier*/
int yywrap()
{
return 1;
}

3.1.2 Code source YACC

%{
/* Definition section */
#include <stdio.h>
#include <ctype.h>
#include <string.h>
#include <stdbool.h>
#include <stdlib.h>
#define YYDEBUG 1
/*======================================================
Color TEXT
========================================================*/
3.1. Code Source de Projet de TP 15

#define RED "\x1B[31m"

#define GRN "\x1B[32m"
#define YEL "\x1B[33m"
#define BLU "\x1B[34m"
#define MAG "\x1B[35m"
#define CYN "\x1B[36m"
#define WHT "\x1B[37m"
/*======================================================
end Color TEXT
========================================================*/
extern FILE *yyin;
int flag=0;
extern int yylex();
/*===================================================
==================================================*/
char getGrammerExp[20][20];
int i_getGrammerExp = 0;
/*===================================================
==================================================*/
struct generate_tac{
char temp_val[1][20]; int is_occupe;
};
int i_generate_tac = 0;
struct generate_tac tble_generate_tac[30];
/*===================================================
Structure de donner code trois adress
==================================================*/
struct expr{
char operand1[1][20];
char operand2[1][20];
char operator[1][20];
char result[1][20];
};int index1=0;
/*===================================================
==================================================*/
char* addtotable(char a[1][20], char b[1][20], char o[1][20]);
/*===================================================
MESSAGE DES ERREURS
==================================================*/
char * invalid_expr = "Entered arithmetic expression is Invalid";
char * invalid_file = "Entered FILE expression is Invalid";
/*====================================================================================
variable global to the draw table
16 Chapitre 3. Realisation Implémentation du PROJET

=================================================================================*/
int nbrSpace_def_case_1 = 2,nbrSpace_def_case_2 = 4;
int counter_dash_line = 65;
char reserved_words[5][11]= {"#","OP","src1","src2","resultat"};//65
char reserved_words_triblet [4][11]= {"#","OP","src1","src2"};//47;-
//***********************************************************************************
/*===================================================================================
FIN PARTIE DE DEFINITION
=====================================================================================*/
%}
%union {
int entier;
float flottant;
char* lett;
struct exp__tac{
float preval;
char* result_tac;
}expression;
}

%type <expression> E

%token <flottant> FLOTTANT

%token <entier> ENTIER
%token <lett> LETTER
%token '(' ')' '\n'
%left '+' '-'
%left '*' '/' '%'

/* Rule Section */
%%

ArithmeticExpression: LETTER '=' E{

printf(GRN);
printf("\n\t |============================================================|\n");
printf("\t\t\t {{Bouchakour}}Resultat=%f", $[Link]);
//printf("\n\t |============================================================|\n");
//printf("\nResult=%f\n", $[Link]);
/*addtotable($1,$3.result_tac,"=");
return 0;*/
getGrammerExp[i_getGrammerExp][0] = '=';i_getGrammerExp++;
3.1. Code Source de Projet de TP 17

};
E:E'+'E {$$.preval=$[Link]+$[Link];
getGrammerExp[i_getGrammerExp][0] = '+';i_getGrammerExp++;
}

|E'-'E {$$.preval=$[Link]-$[Link];
getGrammerExp[i_getGrammerExp][0] = '-';i_getGrammerExp++;
}

|E'*'E {
$$.preval=$[Link]*$[Link];
getGrammerExp[i_getGrammerExp][0] = '*';i_getGrammerExp++;
}

|E'/'E {$$.preval=$[Link]/$[Link];
if($[Link]==0){
yyerror("Diviser par ZERO");

}else{
getGrammerExp[i_getGrammerExp][0] = '/';i_getGrammerExp++;
}

|'('E')' {$$.preval=$[Link];}

| FLOTTANT {$$.preval=$1;

/*char r[10];float n = $$.preval;

sprintf(r,"%f",n);
$$.result_tac = r;*/
char r[10];float n = $$.preval;
sprintf(r,"%.2f",n);
$$.result_tac =(char*) r;int sss = 0;
while(r[sss]!= '\0'){
getGrammerExp[i_getGrammerExp][sss] = r[sss];
sss++;
}
i_getGrammerExp++;
//getGrammerExp[i_getGrammerExp] = r;i_getGrammerExp++;
printf("-- %s rr=%s\n",getGrammerExp[i_getGrammerExp],r);
18 Chapitre 3. Realisation Implémentation du PROJET

| ENTIER {
$$.preval=(float)$1;
char r[10];float n = $$.preval;
sprintf(r,"%.2f",n);
$$.result_tac =(char*) r;int sss = 0;
while(r[sss]!= '\0'){
getGrammerExp[i_getGrammerExp][sss] = r[sss];
sss++;
}
i_getGrammerExp++;
//getGrammerExp[i_getGrammerExp] = r;i_getGrammerExp++;
printf("-- %s rr=%s\n",getGrammerExp[i_getGrammerExp],r);
}

%%

void yyerror(char const *message)

{
printf(RED);
printf("\n\t |============================================================|\n");
printf("\n\t\t%s\n",message);
printf("\n\t |============================================================|\n");
printf(WHT);
flag=1;
exit(0);
}
//driver code
struct expr arr[20];
char* addtotable(char a[1][20], char b[1][20], char o[1][20]){

char buf[20];

strcpy(arr[index1].operand1[0],a[0]);
strcpy(arr[index1].operand2[0],b[0]);
strcpy(arr[index1].operator[0],o[0]);
snprintf(buf,3,"t%d",index1);
3.1. Code Source de Projet de TP 19

strcpy(arr[index1].result[0],buf);

index1++;
char *h = buf;
return h;
}

int find(char l[1]){

int i;
for(i=0;i<index1;i++)
if( strcmp( arr[i].result[0] , l) == 0) break;
// if(arr[i].result==l) break;
return i;
}

/*==============================================================================
DRAW table programme
=================================================================================*/
void ecrire(char *s){
printf("%s",s);
}
//-----------------------------------------//--------------------//--------------------//---
int calcSpaceContentCase(int len_word,int len_case_header){
return len_case_header - len_word;
}
void printDashLine(int total_len_table){
for(int i =1;i<=total_len_table;i++){
if(( i == 1)||(i == total_len_table)){
ecrire("+");
}else{
ecrire("-");
}
}
ecrire("\n");
}
void threeAdd(){

int i=0;
printf("\t\t");
printDashLine(34);
20 Chapitre 3. Realisation Implémentation du PROJET

while(i<index1){
printf("\t\t|");
printf("%s:=\t",arr[i].result[0]);
printf("%s\t",arr[i].operand1[0]);
printf("%s\t",arr[i].operator[0]);
printf("%s\t",arr[i].operand2[0]);
printf("||");
i++;
printf("\n");
}
printf("\t\t");
printDashLine(34);
}
//
void printSpaceDefaultEachCase_Header(int witch_case){
for(int space = 0;space < witch_case;space++){
ecrire(" ");
// counter_dash_line++;
}
}
//
void _printWORD_(char word[1]){
/*for(int j = 0;word[1][j]!='\0';j++){
printf("%c",word[1][j]);
}*/
printf("%s",word);
}
//----------
void printHeaderOftable(int countHeader){
for(int i = 0;i<countHeader;i++){
// ecrire(reserved_words[i]);ecrire(" ");
ecrire("|");counter_dash_line++;
if( i == 0 ){
printSpaceDefaultEachCase_Header(nbrSpace_def_case_1);
}else{
printSpaceDefaultEachCase_Header(nbrSpace_def_case_2);
}
bool si_quadruple_sinon_triblet = (countHeader == 5);
if(si_quadruple_sinon_triblet){
_printWORD_(reserved_words[i]);
}
else{
_printWORD_(reserved_words_triblet[i]);
3.1. Code Source de Projet de TP 21

if( i == 0 ){
printSpaceDefaultEachCase_Header(nbrSpace_def_case_1);
}else{
printSpaceDefaultEachCase_Header(nbrSpace_def_case_2);
}
ecrire("|");//counter_dash_line++;
}
}
int calcWholeLenthContent_Header_Case(int spaceCase,char word[1]){
return spaceCase*2+strlen(word);
}

void drawOneRow(){

//print one row

for(int i = 0;i<index1;i++){

/*========================================================================================
- classiffy all date i case
==========================================================================================*/
char buffer_number_of_line[50];
sprintf(buffer_number_of_line, "(%d)", i);
char *linContent[5] = {
buffer_number_of_line,
arr[i].operator[0],
arr[i].operand1[0],
arr[i].operand2[0],
arr[i].result[0],
};
printf("\t");
for(int j = 0;j<5;j++){
/*==========================================================================================
test if the first index or not
============================================================================================
bool first_index = (j==0);

int nbrContentLen=0;
if(first_index){
nbrContentLen = calcWholeLenthContent_Header_Case(nbrSpace_def_case_1,reserved_words[j]);
}else{
nbrContentLen = calcWholeLenthContent_Header_Case(nbrSpace_def_case_2,reserved_words[j]);
22 Chapitre 3. Realisation Implémentation du PROJET

}
/*=======================================================================================
calculate dynamic space content padding all then divide by 2 , get padding
left , padding right
==========================================================================================*/
int halfPaddingContent = calcSpaceContentCase(strlen(linContent[j]),nbrContentLen)/2;
/*=========================================================================================
print the content data
==========================================================================================*/

ecrire("|");
printSpaceDefaultEachCase_Header(halfPaddingContent);
_printWORD_( linContent[j] );
printSpaceDefaultEachCase_Header(halfPaddingContent);

bool si_add_space_if_impair_space = (calcSpaceContentCase(strlen(linContent[j]),

nbrContentLen)%2 !=0);
if(si_add_space_if_impair_space){
ecrire(" ");
}
ecrire("|");
}
ecrire("\n");
//printDashLine(65);

}
}
void drawOneRowTriplet(){
/*=========================================================================
Draw lines on Tribet
1- genetete the data content into list
2- Shown the data
-------------------
segement utlise:
char reserved_words_triblet [4][11]= {"#","OP","src1","src2"};//47;-
struct expr{
char operand1[1][20];
char operand2[1][20];
char operator[1][20];
char result[1][20];
};int index1=0;
donner List :
{
3.1. Code Source de Projet de TP 23

(i),
char operand1[1][20];
char operand2[1][20];
char operator[1][20];
}
===========================================================================*/
//***********************GENERTE THE DATA*************************

for(int i = 0;i<index1;i++){
//***********************GENERTE THE DATA*************************
char buf_number_line[20],buf_src1[20],buf_src2[20];
sprintf(buf_number_line,"(%d)",i);

if(arr[i].operand1[0][0] != 't'){
//printf("%s\t",arr[i].operand1[0]);
sprintf(buf_src1,"%s",arr[i].operand1[0]);
}
else{
/*printf("pointer");
printf("%d\t",find(arr[i].operand1[0]));*/
sprintf(buf_src1,"pointer(%d)",find(arr[i].operand1[0]));
}

if(arr[i].operand2[0][0] != 't'){
//printf("%s\t",arr[i].operand2[0]);
sprintf(buf_src2,"%s",arr[i].operand2[0]);
}
else{
/*printf("pointer");
printf("%d\t",find(arr[i].operand2[0]));*/
sprintf(buf_src2,"pointer(%d)",find(arr[i].operand2[0]));
}
/****************** LIST DE DONNER TABLEUX *******************
char buf_number_line[20],buf_src1[20],buf_src2[20];
===============================================================*/
char *linContent[4] = {
buf_number_line,
arr[i].operator[0],
buf_src1,
buf_src2,
};
/*===================================
SHOW THE DATA
24 Chapitre 3. Realisation Implémentation du PROJET

====================================*/
printf("\t\t");
for(int j = 0;j<4;j++){
/*==========================================================================================
test if the first index or not
============================================================================================
bool first_index = (j==0);

int nbrContentLen=0;
if(first_index){
nbrContentLen = calcWholeLenthContent_Header_Case(nbrSpace_def_case_1,
reserved_words[j]);
}else{
nbrContentLen = calcWholeLenthContent_Header_Case(nbrSpace_def_case_2,
reserved_words[j]);
}
/*=======================================================================================
calculate dynamic space content padding all then divide by 2 , get padding
left , padding right
==========================================================================================*/
int halfPaddingContent = calcSpaceContentCase(strlen(linContent[j]),nbrContentLen)/2;
/*=========================================================================================
print the content data
==========================================================================================*/
ecrire("|");
printSpaceDefaultEachCase_Header(halfPaddingContent);
_printWORD_( linContent[j] );
printSpaceDefaultEachCase_Header(halfPaddingContent);

bool si_add_space_if_impair_space = (calcSpaceContentCase(strlen(linContent[j]),

nbrContentLen)%2 !=0);
if(si_add_space_if_impair_space){
ecrire(" ");
}
ecrire("|");
}
ecrire("\n");

}
}
/*=============================================================
drawTable() : Affichage du tableaux QUADRUPLE
3.1. Code Source de Projet de TP 25

drawTableTriblet() : Affichage de tableaux TRIPLE

==============================================================*/
void drawTable(){
printf("\t");
printDashLine(65);
printf("\t");
printHeaderOftable(5);
ecrire("\n");
printf("\t");
printDashLine(65);
drawOneRow();
//ecrire("\n");
printf("\t");
printDashLine(65);
}
void drawTableTriblet(){
printf("\t\t");
printDashLine(47);
printf("\t\t");
printHeaderOftable(4);
ecrire("\n");
printf("\t\t");
printDashLine(47);
drawOneRowTriplet();
printf("\t\t");
printDashLine(47);
}
/*=====================================================================================
FIN DRAW TABLE FUNCTION
================================================================================*/
void menu_code_inter_m(){
printf("\n\t |=====================================|\n");
printf("\t\t Generetion Code intermidiare \n");
printf("\t |=====================================|\n");
printf("\t\t4- |-Code Trois Adress \n");
printf("\t\t5- |-Quadruple \n");
printf("\t\t6- |-Triplet \n");
printf("\t\t7- |-QUIT");
printf("\n\t |===================================|\n");
}
void menu_principale(){
printf("\t |===================================|\n");
printf("\t\t Bienvenu Compilation \n");
26 Chapitre 3. Realisation Implémentation du PROJET

printf("\t |===================================|\n");
printf("\t\t1- Par fichier \n");
printf("\t\t2- par commend \n");
printf("\t\t3- QUIT");
printf("\n\t |===================================|\n");
}

void scanExpr(){
for(int i = 0;i<i_getGrammerExp;i++){
printf("%s|",getGrammerExp[i]);
}
ecrire("\n");
ecrire("================================================");
ecrire("\n");
}
void main()
{
menu_principale();
int answer_1;
printf("|===========|-Enter your answer: ");
scanf("%d",&answer_1);

printf(YEL);
if(answer_1 == 1){
/*===============================================================
Si Choix (1) alors demende enree [Link]
qui contient expression arithmitique
==============================================================*/
char file_in[256], file_out[256];

char * line1;
printf(WHT);
printf("\n|==================================================|");
printf("\n|==================================================|");
printf("\nEnter Fichier Source Arithmetic Expression which : ");

//fgets(file_in,256,stdin);
scanf("%s",file_in);
printf(WHT);
FILE *in_file = fopen(file_in, "r");
if(!in_file){
yyerror(invalid_file);
3.1. Code Source de Projet de TP 27

}else{
yyin = in_file;
do{
yyparse();
}while(!feof(yyin));
}
fclose(yyin);
}else if(answer_1 == 2){
char * line;
printf(WHT);
printf("\n|==================================================|");
printf("\n|==================================================|");
printf("\nEnter Any Arithmetic Expression which : ");
scanf("%s",line);
printf(WHT);
yyparse();
}else{
printf(YEL);
printf("\n================================THANKYOU=================\n");
printf(WHT);
exit(0);
}

if(flag==0){
printf(GRN);
printf("\n\n\t\tMarinFord-Entered arithmetic expression is Valid");
printf("\n\t |============================================================|\n");
printf(WHT);
/*==================================================
PARTIE C : - generation TROIS ADRESS
-Affichage tableux quadruple et triple
===================================================*/
scanExpr();

for(int i = 0;i<i_getGrammerExp;i++){

char src1[1][20] ;char if_src1_not_number_case_2[1][20];char src2[1][20] ;char oprt[1][20] ;

if( getGrammerExp[i][0] == '+' ||

getGrammerExp[i][0] == '-' ||
getGrammerExp[i][0] == '*' ||
getGrammerExp[i][0] == '/'){
28 Chapitre 3. Realisation Implémentation du PROJET

char is_t[1][20];char* buf = "";

if((index1>0) && ( strcmp(tble_generate_tac[i-1].temp_val[0],

arr[index1-1].result[0] ) == 0)){
//
//printf("enter");
strcpy(src2[0],tble_generate_tac[i-1].temp_val[0]);

tble_generate_tac[i-1].is_occupe = 1;
//find prevois src 2 -->; src 1;
for(int previous = 0;previous<i-1;previous++){
if(tble_generate_tac[previous].is_occupe == 0){
strcpy(src1[0],
tble_generate_tac[previous].temp_val[0]);
//printf("src1 = %s\n",src1[0]);
tble_generate_tac[previous].is_occupe = 1;
}
}

}else{
//---------------

if((index1>0) && ( strcmp(tble_generate_tac[i-2].temp_val[0]

,arr[index1-1].result[0] ) == 0)){
//printf("->>-%s-<<-%s-->",tble_generate_tac[i-2].temp_val[0],arr[index1-1].result[0]);
strcpy(src1[0],arr[index1-1].result[0]);
}else{
strcpy(src1[0],getGrammerExp[i-2]);
}

tble_generate_tac[i-2].is_occupe = 1;
//---------------
strcpy(src2[0],getGrammerExp[i-1]);
tble_generate_tac[i-1].is_occupe = 1;
//-----------------

}
strcpy(oprt[0],getGrammerExp[i]);
3.1. Code Source de Projet de TP 29

r = addtotable(src1,src2,oprt);
//----------add new item
tble_generate_tac[i].is_occupe = 0;
strcpy(tble_generate_tac[i].temp_val[0] , r);

}else{
tble_generate_tac[i].is_occupe = 0; strcpy(tble_generate_tac[i].temp_val[0] ,
getGrammerExp[i]);
}
printf("%s | ",tble_generate_tac[i].temp_val[0]);
}

printf(CYN);
/*======================================================
Fin traitement PARTIE C
========================================================*/
menu_code_inter_m();
printf(YEL);
while(true){
int answer_c;
printf(WHT);
printf("|===========|-Enter your answer: ");
scanf("%d",&answer_c);
if(answer_c == 4){
//printf("\n------------three adress code-----------------------\n");
printf(YEL);
printf("\n\t |============================================================|\n");
printf("\t\t\t {{Code Trois Adresse}}");
printf("\n\t |============================================================|\n");
printf(CYN);
threeAdd();
}else if(answer_c == 5){
//--------------------------quadruple
printf(YEL);
printf("\n\t |============================================================|\n");
printf("\t\t\t\t{{Quadruple}}");
printf("\n\t |============================================================|\n");
//fouradd();
//ecrire("\n");
printf(CYN);
drawTable();

}else if(answer_c == 6){

30 Chapitre 3. Realisation Implémentation du PROJET

//printf("\n-----------triplet-----------\n");
printf(YEL);
printf("\n\t |============================================================|\n");
printf("\t\t\t\t{{Triplet}}");
printf("\n\t |============================================================|\n");
//triple();
printf(CYN);
drawTableTriblet();
}else{
printf(YEL);
printf("\n===========================<THANKYOU>================\n");
printf(WHT);
exit(0);
}
}

}
}
/*================================================================
FIN LE PROGRAMME MERCI POUR SUIVRE AVEC MOI
================================================================*/
3.2. Capture d’ecrant montre d’execution 31

3.2 Capture d’ecrant montre d’execution

Figure 3.1 – Capture Ecrant 1

32 Chapitre 3. Realisation Implémentation du PROJET

Figure 3.2 – Capture Ecrant 2

3.2. Capture d’ecrant montre d’execution 33

Figure 3.3 – Capture Ecrant 3

34 Chapitre 3. Realisation Implémentation du PROJET

Figure 3.4 – Capture Ecrant 4]

3.2. Capture d’ecrant montre d’execution 35

Figure 3.5 – Capture Ecrant 5

Figure 3.6 – Capture Ecrant 6

36 Chapitre 3. Realisation Implémentation du PROJET
3.2. Capture d’ecrant montre d’execution 37

Conclusion générale
Grâce à ce projet, nous menons un projet de sa conception à sa réalisation. Chaque étape nous à
permis d’approfondir les connaissances et les compétences acquises durant notre formation. Après
une période de recherche et après la réalisation de ce projet, nous avons eu une bonne occasion
d’acquérir de nouvelles connaissances. L’objectif visé par ce travail est de concevoir et d’implémenter
un système de gestion d’un magasin de vêtement. Le problème primordial était d’automatiser les
différentes procédures manuelles existantes, ce qui implique le gain du temps et de minimiser les
erreurs de calcul qui peuvent surgir durant les différents traitements. Cette étude nous a permis
de renforcer nos aptitudes, notamment, la conduite d’un projet informatique, l’esprit d’analyse, le
travail de groupe, comment faire la collecte d’informations nécessaires pour notre étude, . . . etc. Ceci
a été une bonne expérience pour nous. Enfin, ce projet nous a été très bénéfique, il nous a permis
de concrétiser nos connaissances théoriques issues des trois années d’études, de connaître de près
l’environnement du travail et d’acquérir et découvrir de nouvelles connaissances qui nous seront très
utiles dans notre vie professionnelle.
Bibliographie

[1] : Support de cource mast

[2] : https ://[Link]/c-programming-language/
Bibliographie 39