UE MAREP Cours 10 : Projet Patricia Renault UPMC 2005/2006.

Présentation au sujet: "UE MAREP Cours 10 : Projet Patricia Renault UPMC 2005/2006."— Transcription de la présentation:

1 UE MAREP Cours 10 : Projet Patricia Renault UPMC 2005/2006

2 2/28 Plan Introduction Objectifs Complexité Présentation

3 3/28 Plan Introduction Durée Méthodologie Objectifs Complexité Présentation

4 4/28 Durée 4 semaines 2 cours - C 10, C 11 2 TD - TD 9, TD 10 4 TME - TME 9, TME 10, TME 11, TME 12 Evaluation durant la dernière séance de TME grâce à des démos

5 5/28 Méthodologie Décomposition du projet en 9 étapes de plus en plus complexes Comment procéder ? Pour chaque étape Ecriture du code d’une étape Test exhaustif de l’étape Si test = ok passage à l’étape suivante Sinon, correction de l’étape La note n’est pas proportionnelle à la quantité de ligne assembleur mais aux étapes validées !!!

6 6/28 Plan Introduction Objectifs Complexité Présentation

7 7/28 Objectifs Récapituler et approfondir les notions abordées : Représentation des nombres Représentation d'une expression arithmétique Interface avec l'utilisateur : saisie et affichage, traduction depuis et vers les structures utilisées pour le calcul Découpage d’un problème en traitements élémentaires, structurations en fonctions Mise en correspondance d'une fonction C avec une de ses traductions possibles en langage d'assemblage

8 8/28 Plan Introduction Objectifs Complexité Présentation

9 9/28 Complexité etape1etape2etape3etape4etape5etape7etape8 etape6etape9 100300 Préparé en TD 9 et 10 12/20

10 10/28 Plan Introduction Objectifs Complexité Présentation Expressions arithmétiques Description globale Décomposition en étapes

11 11/28 Expressions arithmétiques Trois types d’expression arithmétiques Infixe : l’opérateur est placé entre les opérandes Exemple : 2 + 3 Préfixe : l’opérateur est placé avant les 2 opérandes Exemple : + 2 3 Postfixe : l’opérateur est placé après les 2 opérandes Exemple : 2 3 + Quel que soit le type d’expression, on peut représenter une expression par un arbre où Les nœuds sont les opérateurs Les feuilles sont les opérandes

12 12/28 Expressions arithmétiques + * + + + * / 20 914 1218 13 2 8

13 13/28 Expression infixée (12+18+2*(13+8)+14*9)/20= 9 + * + + + * / 20 914 1218 13 2 8

14 14/28 Expression préfixée / + + + 12 18 * 2 + 13 8 * 14 9 20 + * + + + * / 20 914 1218 13 2 8

15 15/28 Expression post-fixée 12 18 + 2 13 8 + * + 14 9 * + 20 / = 9 + * + + + * / 20 914 1218 13 2 8 Utilisé dans le projet

16 16/28 Expression post-fixée Parcours (Arbre){ Si Arbre = Feuille retourner valeur(Feuille). Si Arbre = Nœud_unaire retourner Applique_op(nœud_unaire(Parcours(Sous_arbre_nœud_unaire))) Si Arbre = nœud_binaire Sous_expr_1 = Parcours(nœud_binaire.Sous_arbre_gauche) Sous_expr_2 = Parcours(nœud_binaire.Sous_arbre_droit) Retourner(Applique_op(nœud_binaire.op, sous_expr_1, sous_expr_2)) } + * + + + * / 20 914 1218 13 2 8

17 17/28 Réalisation saisir_chaine structurer_expr evaluer_expr convertir_entier Afficher résultat expr. valide? oui non Débu t

18 18/28 Réalisation int main(){ char e_ch[64]; Expr_struct_elem e_str[32]; int ok = 0, nb; while (ok == 0){ saisir_chaine(e_ch); if (structurer_expr(e_ch, e_str) == 1) ok = 1; printf("Expr KO\n"); } nb = evaluer_expr(e_str); printf("expression %s=%d\n",e_ch,nb); return 0; }

19 19/28 Réalisation - expression structurée typedef struct expr_struct_elem { char type; char operat; unsigned short int operand;/* 2 octets */ }Expr_struct_elem; Octet 0Octet 1Octet 2 et octet 3 TypeOpérateurOpérande Attention opérande = o3o2 Opérateur unaire 0# Opérateur binaire 0+ 1- 2* 3/# Type 0Fin d’expression 1opérande 2Opérateur binaire 3Opérateur unaire

20 20/28 Réalisation - étape 5 void saisir_chaine(char *expr_chaine) Demande la saisie d’une expression postfixée Effectue la saisie Vérifie que la chaîne saisie ne contient que des caractères valides Répète ces opérations jusqu’à obtenir une chaîne syntaxiquement correcte. Exemples : 2 3 + est valide z % r est invalide

21 21/28 Réalisation - étape 4 int structurer_expr(char *expr_chaine, Expr_struct_elem *expr_struct) Converti la chaîne saisie en une expression structurée Exemple chaîne saisie : 2 3 +, l’expression structurée sera 0x01 00 02 00 (pour 2) 0x01 00 03 00 (pour 3) 0x02 00 00 00 (pour +) 0x00 00 00 00 (pour fin d’expression structurée) Exemple : 4 1 * 5 2 - /

22 22/28 long evaluer_expr(Expr_struct_elem *e_str) Evalue l’expression structurée passée en argument en appliquant l’algorithme de parcours Nécessite l’utilisation de la pile pour évaluer cette expression structurée et des fonctions empile et dépile Réalisation - étape 4

23 23/28 long evaluer_expr(Expr_struct_elem *e_str) { Pile P ;/* un tableau de 32 entiers et deux fonctions d’accès : empiler(P,e) et dépiler(P)*/ Indice i ; i = indice du premier élément de e_str while (e_str[i].type != fin_expr) { if (e_str[i].type == OP) /* operande */ empiler(P, Expr[i].operande); Réalisation - étape 4

24 24/28 else /*op unaire*/if (e_str[i].type = OPERUN) { V1 = dépiler(P); V2 = appliquer_op( e_str[i].operateur, V1); empiler(P,V2); } else { /* opérateur binaire */ V1 = dépiler(P); V2 = dépiler(P); Réalisation - étape 4

25 25/28 V3 = appliquer_op( e_str[i].operateur, V1, V2); empiler(P,V3); } /* fin si interne */ }/* fin si externe */ i = indice elem suivant e_str } /* Fin while */ return (dépiler(P)); } Réalisation - étape 4

26 26/28 Réalisation - étape 4 Fonctionnement de l’algorithme précédent sur 4 1 * 5 2 - / 4 est un opérande => empile (P, 4) 1 est un opérande => empile (P, 1) * est un opérateur => dépile (P, op2), dépile (P, o1), applique op1 * op2 puis empile (P, op1*op2) 5 est un opérande => empile (P, 5) 2 est un opérande => empile (P, 2) - est un opérateur => dépile (P, op2), dépile (P, o1), applique op1 - op2 puis empile (P, op1-op2) / est un opérateur => dépile (P, op2), dépile (P, o1), applique op1 / op2 puis empile (P, op1/op2) Fin d’expression => dépile (P, résultat)

27 27/28 Réalisation - étape 4 Une expression postfixée est valide si elle est réductible par l’algorithme d’évaluation à un nombre. Ce nombre est l’unique élément de la pile à la fin de l’algorithme d’évaluation. Règles de validité : en parcourant l’expression post-fixée de gauche à droite, Il y a toujours plus d’opérandes que d’opérateurs binaires. A la fin, la différence entre le nombre d’opérandes et d’opérateurs binaires est de 1 exactement.

28 28/28 Réalisation Etape 1 : Evaluation d’une expression structurée valide ne contenant qu’un seul opérateur binaire Etape 2 : Evaluation d’une expression avec table d’indirection pour déterminer l’adresse du saut Etape 3 : Evaluer d’une expression structurée valide avec plusieurs opérateurs binaire Etape 4 : Structuration d’une expression à partir d’une chaîne de caractère mise en mémoire composée de nombre à un chiffre sans séparateur Etape 5 : Saisie d’une chaîne de caractère et vérification de la validité des caractères saisis