REPUBLIQUE DU SENEGAL Un peuple – un but – une foi
MINISTERE DE L’ENSEIGNEMENT TECHNIQUE ET DE LA FORMATION PROFESSIONNELLE DIRECTION DE LA FORMATION PROFESSIONNELLE
(Pour l’obtention du diplôme d’analyste programmeur)
Présenté par Monsieur Adama MBODJI
Encadré par M. Moussa BA
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
2
Je dédie ce mémoire à mes parents Souleymane MBODJI et Aminata NDIANOR, à mes frères Mamadou Birane, Yaya, Oumar Soulé et à ma sœur Sourouro Belly.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
3
Je voudrais tout d’abord exprimer ma très profonde reconnaissance à mon père Souleymane MBODJI et à ma mère Aminata NDIANOR. Je ne saurais trouver les mots pour remercier mon beau frère Mouhamadou Lamine BALDE, mon ami Ibrahima DIAWARA, mon professeur de Mérise Lamine DIOP et mon oncle Abou NDIANOR pour la correction de ce mémoire. Je remercie vivement Docteur Kéba DIOP pour ses cours d’algorithme qu’il dispense à l’I.F.P, qui ont illuminé davantage ma méthode de réflexion. Que M. Moussa BA professeur du langage Pascal à l’I.F.P, qui a mis en pratique le logiciel MSAlgoPascal® avec ses étudiants de la première année et ayant largement participé à son déboguage, trouve ici l’expression de ma profonde gratitude. J’exprime également ma reconnaissance à mes amis Vieux S. COLY et Adja N. M. DIENG pour l’administration des questionnaires. Je remercie également tous mes professeurs de l’I.F.P qui ont su me donner une formation de qualité. Pour finir, je ne citerai pas de noms, au risque d’en omettre certains, pour exprimer mes sincères remerciements à tous ceux qui, de près ou de loin, ont contribué à la réalisation de MSAlgoPascal®.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
A.D.S.L
Asymetric Digital Suscriber Line
C.I.F
Contraintes d’Intégrités Fonctionnelles
Go
Giga octets
I.F.P
Institut de Formation Professionnelle
M.C.D
Modèle Conceptuel des Données
M.C.T
Modèle Conceptuel des Traitements
M.L.D
Modèle Logique des Données
MHz
Mega Hertz
Mo
Mega octets
R.A.M
Random Access Memory
R.G
Règle de Gestion
S.G.B.D
Système de Gestion de Base de Données
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
4
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
5
Pour faciliter la lecture des algorithmes, nous mettrons en paysage les pages où ils se situent.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Dédicaces Remerciements Glossaire Errata Plan
Introduction ............................................................................... 8
I) Généralités .............................................................................. 11 1.1 Présentation générale de l’I.F. P. ........................................................... 11 1.2 Organisation ........................................................................................... 12 1.3 Organigramme ........................................................................................ 12
II) Etude de l’existant ................................................................ 13 2.1 Présentation du secteur informatique ..................................................... 13 2.2 Présentation du domaine d’étude ........................................................... 15 2.3 Critiques et problématique de l’existant ................................................ 15 2.3 Proposition de solutions ......................................................................... 16
III) Conception générale ........................................................... 18 3.1 Niveau conceptuel des données ............................................................. 18 3.1.1 Définition de quelques concepts ............................................................ 18 3.1.2 Dictionnaire des données ....................................................................... 19 3.1.2.1 Liste des mots-clés de l’algorithme associés à leur désignation en langage Pascal ..... 20 3.1.2.2 Liste des mots réservés .................................................................................................. 21
3.1.3 Règles de Gestion ................................................................................... 3.1.4 Modèle Conceptuel des Données ........................................................... 3.1.5 Niveau logique des données ................................................................... 3.1.6 Implémentation du modèle logique des données ...................................
22 23 24 24
3.2 Présentation de l’algorithme ................................................................... 25 3.2.1 Définition de l’algorithme ...................................................................... 25 Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
6
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
3.2.2 Structure générale d’un algorithme ........................................................ 3.2.3 Les opérateurs ......................................................................................... 3.2.4 Les types de données .............................................................................. 3.2.5 Les instructions ....................................................................................... 3.2.6 Les sous programmes .............................................................................
25 28 29 34 37
3.3 Exemples d’erreurs ................................................................................. 38
3.4 Diagramme enchaînement des tâches entre l’utilisateur et le logiciel .... 42 3.5 Fiche descriptive des documents ............................................................ 45 3.6 Fiche descriptive des tâches ................................................................... 45 3.7 Analyse des tâches ................................................................................. 46 3.7.1 Fonction AnalyseDeclareVariable (donnée AlgoTexte) : Booléen ....... 3.7.2 Fonction DeclareVariable (donnée AlgoTexte) : Booléen...................... 3.7.3 Fonction AnalyseCondition (donnée AlgoTexte) : Booléen ................... 3.7.4 Fonction ControleExpression (donnée AlgoTexte) : Booléen ................ 3.7.5 Procédure Traduction (donnée AlgoTexte) ............................................
47 58 63 71 74
IV) Présentation de MSAlgoPascal® ........................................ 77 4.1 Configuration requise ............................................................................. 77 ® 4.2 Installation de MSAlgoPascal .............................................................. 77 ® 4.3 Pas à pas sur MSAlgoPascal ................................................................ 79
V) MSAlgoPascal® comme support didactique ....................... 90 5.1 Période d’administration des questionnaires .......................................... 90 5.1.1 Questionnaire du mois d’avril ................................................................ 90 5.1.2 Questionnaire du mois de mai ................................................................ 91 5.1.3 Questionnaire du mois de juin ................................................................ 93
5.2 Appréciations .......................................................................................... 94 5.2.1 Appréciations des étudiants .................................................................... 94 5.2.2 Appréciation du professeur de Pascal ..................................................... 95
Conclusion .................................................................................. 97 Bibliographie .............................................................................. 98 Annexes . .................................................................................... 99
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
7
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
8
ujourd’hui avec le développement des sciences et des technologies, nous sommes parvenus au monde de la programmation à la 4ème génération. Nous sommes passés du binaire à l’assembleur puis des langages procéduraux aux langages événementiels et objets.
A
Derrière toutes ces innovations, aussi complexes qu’elles soient, nous répétons toujours le même processus pour résoudre un problème en informatique. Cette résolution peut être schématisée comme suit :
Problème
Analyse
Algorithme
Langage
Compilation
+ Données
Résultat
Exécution
Edition des liens
Figure 1. Cycle de vie de la résolution d’un problème en informatique.
Nous pouvons retenir que la résolution d’un problème en informatique passe par la production d’un texte appelé algorithme. Ce dernier décrit l’ensemble des opérations élémentaires qui seront exécutées par un ordinateur via un langage de programmation pour obtenir la solution informatique. Ainsi la question qu’on pourrait se poser serait de savoir pourquoi toutes ces générations ? En effet, l’essence de l’informatique est de faciliter la tâche aux utilisateurs. On peut aisément comprendre pourquoi y a-t-il plus d’informaticiens aujourd’hui qu’il y en avait vingt ans auparavant. Plus nous rendons les langages de programmation conviviaux, plus nous élargissons le monde de l’informatique. A qui donc sont destinés tous ces langages de programmation ? Sont-ils pour les néophytes ? Les compétences des débutants se limitent à l’analyse des problèmes et à l’écriture des algorithmes (cf. figure 1 niveaux 2 et 3) ; raison pour laquelle il est difficile, voire même fastidieux pour les débutants de codifier, de corriger les syntaxes et de déboguer leurs programmes. La difficulté majeure que rencontrent le plus souvent les néophytes est d’effectuer correctement le passage d’un algorithme au code correspondant dans un langage de programmation donné en particulier le Pascal. Notre travail consiste à leur faciliter la tâche par la production d’un logiciel qui effectue le passage automatique de l’algorithme au langage Pascal. C’est l’objet de notre étude. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
9
Ainsi, dans le cadre de notre mémoire, nous nous proposerons de présenter en premier lieu le secteur informatique de l’Institut de Formation Professionnelle (I.F.P) en vue d’en faire un diagnostic. Ensuite présenter les différents algorithmes et structures de données mis en place pour la conception d’un logiciel traducteur d’algorithme en langage Pascal et enfin montrer quelques résultats issus de l’utilisation de ce produit par des étudiants de l’I.F.P.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
10
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
11
1.1 Présentation générale de l’I.F.P Situé aux allées Papa Guèye FALL de DAKAR, l’Institut de Formation Professionnelle (I.F.P-Sénégal) est un établissement d’enseignement supérieur privé reconnu par le décret 881212 et agrée par l’Etat du Sénégal. Il a été crée en 1984 par M. Sémi BOUKAROUM. C’est le premier institut de formation privé du Sénégal. La vocation de l’I.F.P-Sénégal est de cultiver l’excellence et de fournir les meilleures prestations possibles dans l’éducation. A ce titre, il a été primé en 2000 d’une Etoile d’Or Internationale par le Président de la République à cause de la qualité de son enseignement. L’Institut de Formation Professionnelle dispose aujourd’hui de plusieurs filières (sections) qui ne sont accessibles qu’aux bacheliers, les cours se font aussi bien de jour comme de soir. Au total, pour l’année scolaire 2003-2004, il compte 494 étudiants venant d’horizons divers dont 355 en cour du jour et 139 pour le soir. Il présente régulièrement ses étudiants à l’examen d’état à savoir le Brevet de Technicien Supérieur (BTS). La formation s’étale sur deux ans et est sanctionnée par un Diplôme de Technicien Supérieur. L’I.F.P anime régulièrement des séminaires de formation. Nous distinguons aujourd’hui les sections suivantes : Informatique de Gestion. Comptabilité. Commerce International. Marketing. Maintenance et Réseau Informatique. Bureautique. Les séminaires se font pour la plupart sur les modules de formation en : Microsoft Word pour le traitement de texte. Microsoft Excel pour les tableurs. Microsoft Power Point pour la présentation sur diaporama. Microsoft Access pour la conception de base de données. AutoCad pour la conception de plan. Microsoft Projet pour la gestion de projet.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
12
1.2 Organisation Le Directeur des Etudes est le coordonnateur général de l’institut. Il est à la base de la conception des emplois du temps des professeurs et du contrôle du bon déroulement des enseignements. Les surveillants ont pour rôle de veiller sur l’ordre au sein de l’établissement. Ils contrôlent les mensualités, l’assiduité et la gestion des bulletins de notes des étudiants. Ils veillent aussi à la ponctualité des professeurs. Les étudiants sont appelés à s’acquitter de leur mensualité au plus tard le 5 de chaque mois auprès du comptable. Au sein de chaque section, un professeur est désigné comme coordonnateur.
1.3 Organigramme Directeur Général
Directeur des études
Comptable
Surveillants généraux
Secrétaire à la direction
Secrétariat
Représentants commerciaux
Session maintenance réseau
Session marketing
Session comptabilité
Session bureautique
Planton
Session commerce internationale
Session informatique
Mécanographe
Agents d’entretien
Figure 2. Organigramme de l’Institut de Formation Professionnelle Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
13
2.1 Présentation du secteur informatique Il a pour vocation de former des informaticiens qui auront à utiliser et à réaliser des systèmes informatiques de très haut niveau. Hormis l’enseignement de l’informatique qui couvre 65% du temps de formation, les enseignements complémentaires dispensés sont : mathématiques et statistiques 20% du temps de formation. comptabilité et économie 15% du temps de formation. L’enseignement vise à donner dans un premier temps une formation pratique solide appuyée sur les bases théoriques nécessaires permettant aux étudiants non seulement de concevoir et de réaliser des programmes de haute technicité, mais également de suivre avec aisance l’évolution rapide de l’informatique. La dernière année de formation étant entre autre consacrée à la rédaction d’un mémoire de fin de cycle portant sur des cas réels de l’école ou de l’entreprise. Le secteur informatique de l’Institut est dirigé par le Docteur-Ingénieur Kéba DIOP. Il est chargé de la supervision et du contrôle des modules dispensés au niveau de la section. Les modules enseignés sont les suivants : Modules Architecture et composants Système d’exploitation Téléinformatique Langage Pascal Langage C++ Mérise Système de gestion de fichier Système de gestion de base de données Bureautique Mathématique Recherche opérationnelle Economie générale Technique quantitative de gestion Négociation informatique Technique d’expression Anglais Total par colonne Total par année
Coefficient 4 3 2 5 5 6 2
Première année Cours TD 30 40 30 40 40 -
TP 20 40 40 -
Deuxième année Cours TD TP 40 30 40 40 90 60 60 -
4
-
-
-
30
-
-
2 4 2 1
40 20
40 -
60 -
40 30 -
40 30 -
-
4
40
60
-
40
40
-
1 1 1 -
30 270 600
30 170 -
160 -
30 30 360 700
30 200 -
140 -
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
14
2.1.1 Matériel disponible La section informatique dispose de quatre (4) salles machines pour les cours de travaux pratiques, de bureautique (Word, Excel et PowerPoint), des langages de programmation (Pascal et C++) et de Système de Gestion de Base de Données (MS Access). Chaque salle a en moyenne vingt (20) micro-ordinateurs. L’une des salles est en même temps un cyber café disposant d’un réseau local et d’une connexion haut débit sur câble paire torsadée classique via ADSL (Asymetric Digital Suscriber Line).
Figure 3. Structure du réseau
Les micro-ordinateurs sont pour la plupart des Pentium II cadencés de 266 à 450 MHz ayant des disques durs variant de 1 à 4 Go avec une mémoire centrale de 32 à 64 Mo.
Figure 4. Salle de travaux pratiques Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
15
Les micro-ordinateurs tournent pour la plupart du temps sur les systèmes d’exploitation suivants : Windows 98, Windows 2000, Windows Millenium et Windows XP.
2.1.2 Corps professoral L’institut dispose d’un corps professoral hautement qualifié ayant une longue expérience professionnelle en entreprise. Au total nous avons vingt deux (22) professeurs : Un (1) Docteur-Ingénieur en informatique. Un (1) Docteur en Lettres. Un (1) Docteur en Anglais. Un (1) DEA en Math. Un (1) DEA en Informatique. Dix (10) Ingénieurs informaticiens. Un (1) Certifié en base de données. Un (1) Diplômé de troisième cycle professionnel en Administration Gestion. Un (1) Maîtrisard en math. Un (1) Diplômé d’études supérieures en comptabilité. Trois (3) Analystes programmeur.
2.2 Présentation du domaine d’étude Le module de langage Pascal englobe notre étude. Il se fait aussi bien en théorie qu’en pratique. La maîtrise du langage Pascal est obligatoire pour la formation d’un technicien supérieur en informatique et son coefficient est de cinq (5) à l’examen final que ce soit pour le BTS ou le DTS. Les cours de travaux pratiques nécessitent obligatoirement un accès à la salle machine (voir fig. 4) pour deux à quatre heures d’application en moyenne par semaine.
2.3 Critiques et problématique de l’existant Un véritable problème de compréhension du langage Pascal est noté et constitue un handicap majeur pour les étudiants. Ce phénomène est dû entre autres aux faits suivants : Les ordinateurs ne disposent pas pour la plupart de compilateur Pascal. Le professeur est ainsi obligé d’en trouver et de l’installer ; ce qui constitue une réelle perte de temps. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
16
Les programmes écrits par les étudiants sont souvent perdus car les ordinateurs ne sont pas protégés par des anti-virus ou le réseau n’est pas du tout fonctionnel pour la protection des données. L’institut ne dispose pas de bibliothèque permettant de faciliter la tâche aux étudiants dans le domaine de la recherche. Le professeur est obligé de les donner l’ensemble des astuces et des raccourcis pour leur faciliter en ce qui est de la programmation en langage Pascal. Les étudiants rencontrent des difficultés pour faire un passage correct de l’algorithme vers le langage Pascal parce qu’ils ne maîtrisent pas l’équivalence des mots algorithmiques en langage Pascal. Par conséquent, les cours d’algorithmique qui sont dispensés sont très en avance par rapport au cours de Pascal. Les étudiants n’ont pas la possibilité de traduire les algorithmes qu’ils font en classe en langage Pascal. Il revient au professeur d’expliquer et de traduire les algorithmes, de déboguer les programmes. Cette situation se répercute même en deuxième année lors de l’apprentissage du langage C++. Le langage Pascal devrait être un support de base pour la maîtrise de ce dernier ; mais tel n’est pas le cas. Est–il possible d’améliorer le système de travail en le substituant en partie par un système informatisé ? Telle est la question à laquelle l’étude que nous mènerons tentera d’apporter des éléments de réponses.
2.4 Proposition de solutions Pour faciliter l’apprentissage du langage Pascal au niveau des étudiants, nous nous proposons de produire un logiciel non seulement capable de vérifier les expressions parenthésées. de vérifier les clauses arborescentes. de vérifier la déclaration des variables, des types, des procédures et des fonctions. d’envoyer des messages d’erreur à l’utilisateur si nécessaire pour lui signaler une erreur donnée au niveau de l’algorithme. d’avoir une base de données qui donne la désignation de chaque mot algorithmique en langage Pascal. d’avoir une aide qui donne la signification de chaque mot algorithmique. d’effectuer la traduction automatique de l’algorithme vers le langage Pascal. d’avoir la possibilité de sauvegarder et d’éditer les algorithmes des utilisateurs. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
17
mais aussi ayant un compilateur Borland Turbo Pascal pour exécuter les algorithmes traduits. un environnement convivial pour faciliter la saisie des algorithmes. une comptabilité sur l’ensemble des versions de Windows sous 32 bits et ne nécessitant pas d’espace mémoire importante pour son fonctionnement. Tels sont les objectifs que nous essayerons de mettre en œuvre par la suite.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
18
Pour concevoir un logiciel traducteur d’algorithme en langage Pascal, nous adopterons une approche dichotomique en distinguant les données des traitements.
3.1. Niveau conceptuel des données 3.1.1 Définition de quelques concepts Le niveau conceptuel consiste à penser le système d’information sans envisager aucun concept d’organisation. Il consiste à se poser la question « Quoi ? » (« Quoi faire ? » et avec quelles données ?»). Le matériel utilisé et la manière dont le travail est fait ne sont pas pris en compte. Le dictionnaire des données Le dictionnaire des données contient toutes les données utilisées par le système qui sont obtenues à partir des interactions avec les utilisateurs. Règles de Gestion (R.G) Elles traduisent les objectifs visés et les contraintes acceptées spécifiées dans le cahier de charge. Ces règles de gestion sont liées aux données et traitements. Modèle Conceptuel des Données (M.C.D) C’est la formulation des données mémorisées dans la base d’information. Cette formulation est la suivante.
Figure 5. Formulation du modèle conceptuel des données
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
19
Objet ou individu ou entité C’est un élément matériel ou immatériel : ayant une existence propre. ayant un intérêt pour le domaine étudié et pour le concepteur. chaque occurrence doit être distinguable au sein de la famille. toutes les occurrences doivent être dotées de la même liste de propriétés. La relation C’est une association : de deux ou plusieurs objets. qui n’a pas d’existence propre. dans laquelle chacune de ces occurrences est distinguable. toutes les occurrences sont caractérisées par une même liste de propriétés. Cardinalité Elle indique pour chaque couple objet-relation les nombres minimum et maximum d’occurrences de la relation pouvant exister pour une occurrence de l’objet. Contraintes d’Intégrités Fonctionnelles (C.I.F) Une CIF sur plusieurs objets est une association au sein d’une même relation qui exprime que l’un de ces objets est totalement identifié par la connaissance des autres. L’identifiant L’identifiant est une propriété particulière de l’objet choisi de telle manière qu’à chaque valeur (occurrence), prise par cette propriété, corresponde une et une seule occurrence de cet objet.
3.1.2 Dictionnaire des données N°
Nom
1
Aide
2
AlgoTexte
3
MotRéservé
Code mnémonique
Signification C’est l’aide associée au mot de l’algorithme. Elle donne la signification et l’utilité de ce mot. C’est le texte de l’algorithme qui est saisi à partir de l’éditeur. C’est un mot réservé uniquement au langage de programmation. Ce mot ne peut être déclaré comme Variable, Type, Constante, Procédure, Fonction, etc.
Type
Taille
Observation
Aide
AN
255
Efface l’Ecran et positionne le curseur au coin supérieur gauche.
AlgoTexte
AN
32 000
-
15
TantQue, Algo, FinSi, Pour, Entier, While, Do, Until, IF etc.
MotReserve
A
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
4
NomAlgo
5
NomPascal
6
NumeroAide
7
Unit
Détermine tous les mots saisis dans un algorithme. C’est la signification associée au mot de l’algorithme en langage Pascal. C’est le numéro de l’aide C’est la librairie (bibliothèque) qui est utilisée pour exécuter un mot en Pascal.
20
NomAlgo
AN
15
EffacerEcran
NomPascal
AN
15
ClrScr
NumAide
N
4
11
Unit
AN
8
CRT, GRAPH, PRINTER
Légende : AN : Alpha numérique A : Alphabétique
3.1.2.1 Liste des mots-clés de l’algorithme associés à leurs significations en langage Pascal Chaque mot d’un algorithme est associé au plus à un mot en Pascal. Ce principe nous permet de dresser le tableau ci-dessous. Algorithme AFFICHER AFFICHERLIGNE ALEATOIRE ALGORITHME ALORS ASCII ATTENTE A_LA_LIGNE BLEU CARACTÈRE CONST COS CREER CVCHAÎNE DE DELAI DIV ECRIRE EFFACERECRAN EFFACERMONITEUR ENTIER ENTIERLONG ENTREESORTIE ET FAIRE FDF FERMERGRAPH FICHIER FINALGO FINAVEC FINLIGNE FINPROCÉDURE
Pascal WRITE WRITELN RANDOM PROGRAM THEN CHR READLN WRITELN BLUE CHAR CONST COS NEW STR OF DELAY DIV WRITE CLRSCR CLRSCR INTEGER LONGINT IORESULT AND DO EOF CLAUSEGRAPH FILE END. END EOFLN END
Algorithme AFFICHERLG AFFICHERTEXTXY ALGO ALLERCL ARRET ASSOCIER AVEC BLANC BOOLÉEN CHAÎNE CONSTANTE COULEURTEXT CREERFICHIER DANS DÉBUT DEPLACERVERS DONNÉE ECRIRELIGNE EFFACERGRAPH ENSEMBLE ENTIERCOURT ENTRÉE ES EXPO FAUX FERMER FF FIN FINALGORITHME FINFONCTION FINPOUR FINPROGRAMME
Pascal WRITELN OUTTEXTXY PROGRAM GOTOXY HALT ASSIGN WITH WHITE BOOLEAN STRING CONST TEXTCOLOR REWRITE IN BEGIN MOVETO WRITELN CLEARDEVICE SET SHORTINT VAR EXP FALSE CLOSE EOF END END. END END END.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
FINSELON FINSON FINTANTQUE GRAPHCOULEUR INITIALISEGRAPH JUSQUA LIRE LOG MAJ MESSAGE MODULO NIL NON OU OUVRIRECRITURE PAS POSTETE PROCÉDURE RACINE RÉELCOMPATIBLE RÉELETENDU REPETER ROUGE SELON SIN SON SSCHAÎNE STYLEPOLICE TAILLEFICH TANTQUE TEXTE TRACELIGNE TRACERLIGNE VAR VERT À
END NOSOUND END SETCOLOR INITGRAPH UNTIL READ LN UPCASE WRITELN MOD NIL NOT OR REWRITE NOT SEEK PROCÉDURE SQRT COMP EXTENDED REPEAT RED CASE SIN SOUND COPY SETTEXTSTYLE FILESIZE WHILE TEXT LINE LINE VAR GREEN TO
FINSI FINSTRUCTURE FONCTION INITALEATOIRE JAUNE LIGNE_SUIVANTE LIRETOUCHE LONGUEUR MAJUSCULE MOD MOT NOIR OCTET OUEXCLUSIF OUVRIRLECTURE PASSON POUR PROGRAMME RÉEL RÉELDOUBLE RÉELSIMPLE RÉSULTAT SAISIR SI SINON SORTIE STRUCTURE TABLEAU TAN TEXTCOULEUR TOUCHEAPPUIE TRACERCERCLE TYPE VARIABLE VRAI
21
END END FUNCTION RANDOMIZE YELLOW WRITELN READKEY LENGTH UPCASE MOD WORD BLACK BYTE XOR RESET NOSOUND FOR PROGRAM REAL DOUBLE SINGLE VAR READLN IF ELSE VAR RECORD ARRAY TAN TEXTCOLOR KEYPRESSED CIRCLE TYPE VAR TRUE
3.1.2.2 Liste des mots réservés Les mots réservés constituent les points fondamentaux à partir desquels sont construits les programmes. Ils servent à spécifier et à structurer tous les concepts qui interviennent dans les programmes ou bien à désigner des entités de base. Pascal AND ARRAY BEGIN BOOLEAN BYTE CASE CHAR CONST CONST DIV DO DOWNTO ELSE END FILE FOR FUNCTION GOTO IF IN
Algorithme ET TABLEAU DÉBUT BOOLÉEN OCTET SELON CARACTÈRE CONST CONSTANTE DIV FAIRE BAS SINON FIN FICHIER POUR FONCTION ALLERCL SI DANS
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
INTEGER LONGINT MOD NIL NOT OF OR PROCÉDURE PROGRAM PROGRAM REAL RECORD REPEAT SET SHORTINT STRING THEN TO TYPE UNTIL VAR VAR WHILE WITH WORD XOR
22
ENTIER ENTIERLONG MOD NIL PAS DE OU PROCÉDURE ALGO PROGRAMME RÉEL STRUCTURE REPETER ENSEMBLE ENTIERCOURT CHAÎNE ALORS À TYPE JUSQUA VAR VARIABLE TANTQUE AVEC MOT OUEXCLUSIF
Certains mots réservés ne sont pas spécifiés dans la liste ci-dessus car ils ne sont pas utilisés pour écrire d’un algorithme.
3.1.3 Règles de Gestion (RG) RG1 : Un mot d’un algorithme a une et une seule signification en Pascal. RG2 : Un mot en Pascal peut avoir un ou plusieurs synonymes en algorithmique. RG3 : Un mot en algorithme a une et une seule aide (signification). RG4 : Une variable ne peut jamais débuter par un chiffre (0 à 9). RG5 : Un mot réservé ne peut être déclaré comme identifiant. RG6 : Un mot réservé ne peut être ni supprimé ni modifié. RG7 : Une variable ne doit jamais être déclarée deux ou plusieurs fois (duplication). RG8 : Une expression parenthésée est dite correcte si elle est correctement parenthésée. RG9 : Un commentaire doit nécessairement être fermé. RG10 : Un commentaire peut s’étendre sur plusieurs lignes. RG11 : Tout schéma conditionnel doit nécessairement être syntaxiquement correct avant la fin de l’algorithme. RG12 : Toute erreur signalée doit être identifiée par son numéro de ligne. RG13 : Un mot non identifié ne doit pas être ignoré lors de la traduction. Tout mot doit être connu (déclaré au préalable). RG14 : Toute variable globale peut être utilisée du début à la fin de l’algorithme. RG15 : Toute variable locale ne peut être utilisée que dans la procédure ou fonction où elle a été déclarée. RG16 : Toute condition « SI » a nécessairement un « ALORS » et un « FINSI ». RG17 : Toute condition « TANTQUE » a un et un seul « FAIRE » et n’est fermée que par un « FINTANTQUE ». RG18 : Toute boucle « REPETER » n’est fermée que par un « JUSQUA ». RG19 : Toute boucle « POUR » a un et un seul « FAIRE » et n’est fermée que par un Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
23
« FINPOUR ». RG20 : Un mot est séparé par les caractères suivants : « » , ; [ ] ^ . : = + * / \ ? ! # ( ) RG21 : Une variable locale peut avoir le même nom que celle d’une variable globale. RG22 : Le début et la fin d'un commentaire sont identifiés par le caractère spécial % RG23 : Pour afficher le caractère % (exemple : 100%), il faut le faire précéder de &. Exemple : Afficher « le pourcentage est de 100 &% ». RG24 : Toute apostrophe « ‘ » trouvée dans une chaîne de caractères est dédoublée lors de la traduction. RG25 : Toute instruction d’affichage et de saisie est parenthésée lors de la traduction. RG26 : L’instruction OuvrirLecture (Nom_fichier) est délimitée lors de la traduction par les symboles (directives de compilation en Pascal) {$I-} ... {$I+} Exemple : OuvrirLecture (Ficli) {$I-} Reset (Ficli) {$I+}
RG27 : Le caractère " (guillemets) est systématiquement traduit par ‘ (apostrophe). RG28 : Toute ligne est terminée lors de la traduction par un « ; » (point virgule) sauf si celleci se termine par l’un des mots suivants : DO, THEN, ELSE, BEGIN, RECORD TYPE, CONST, VAR, REPEAT, OF, AND, OR, XOR.
3.1.4 Modèle Conceptuel des Données (MCD) A l’aide du dictionnaire des données et des règles de gestion, nous pouvons ainsi élaborer le Modèle Conceptuel des Données (MCD).
Figure 6. Modèle conceptuel des données
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
24
3.1.5 Niveau logique des données 3.1.5.1 Le formalisme relationnel La traduction du schéma conceptuel validé, exprimé dans le formalisme individuel en un modèle logique de type relationnel, est entièrement automatique grâce aux règles suivantes : Les propriétés : Chaque propriété du MCD devient un attribut. Les objets : Chaque objet conceptuel devient une relation ou une table et son identifiant sa clé primaire. Les relations : Nous distinguons deux cas suivant le type de la relation :
Les relations binaires de type père-fils (m, n)-(1,1) ou (m, n)-(0,1) avec m = 0 ou 1 La relation du formalisme individuel n’apparaît plus en tant que tel dans le schéma relationnel, néanmoins les attributs qu’elle contient seront conservés et exprimés par la migration de l’identifiant de l’objet père dans la table issue de la transformation de l’objet fils.
Les autres relations Pour toutes les autres relations, leurs transformations génèrent une table et la clé de la table sera composée de l’ensemble des identifiants des objets de sa collection. Si la relation était porteuse de propriétés, celles-ci deviendraient des attributs de la table issue de la transformation de la relation conceptuelle.
3.1.6 Implémentation du modèle logique des données Nous utiliserons un système de gestion de base de données du type relationnel pour implémenter les données.
Figure 7. Implémentation sur MS Access 2003 Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
25
MLD Relationnel : BIBLIOTHEQUE (Unit) MotPASCAL (NomPASCAL, Unit) MotALGO (NomALGO, NomPASCAL, NumAide) AIDE (NumAide, Aide) Note : Les clés primaires sont mises en gras et soulignées, les clés secondaires sont doublement soulignées.
3.2. Présentation de l’algorithme 3.2.1 Définition de l’algorithme « L’algorithme est la description d’un ensemble fini d’actions et d’informations élémentaires destinées à être exécutées par un ordinateur pour résoudre un problème. L’algorithme est une suite d’actions ordonnées sur un ensemble fini d’objets. Il doit être défini sans ambiguïté, et son exécution doit s’arrêter après un nombre fini d’opérations élémentaires ». DIOP, Kéba.- Algorithmique et Structures de données Tome 1.- Presse de l’université de l’UNIS page 8.
L’algorithme se construit simplement à partir de mots-clés et de conventions, « en français », en utilisant un certain nombre de principes directeurs. Un algorithme bien fait se doit d’être optimisé et correctement conçu, de sorte que sa traduction en langage de programmation soit rapide, quasiment systématique et corresponde à un programme qui fonctionne de manière optimale. Algorithmes + Structures de données = Programmes Equation de Niklaus WIRTH. DELANNOY, Claude. - Programmer Windows avec Borland C++ 4.5. - Eyrolles page 10.
3.2.2 Structure générale d’un algorithme Algo ou Algorithme ou Programme Nom_Algo Constante ou Const nom_constante = Valeur Type % définition de type de données % Variable ou Var % liste des variables % Procédure Nom_Procédure1 Type2) Début % Instruction % FinProcédure
(donnée
Nom_Var1 :
Type1 ;
Résultat
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Nom_Var2 :
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
26
Fonction Nom_Fonction (donnée Nom_var i : Type i) : Type de résultat Début % Instruction % Nom_Fonction = Valeur retour FinFonction % PROGRAMME PRINCIPAL % Début % Instruction % FinAlgo ou FinAlgorithme ou FinProgramme
Donc la structure générale d’un algorithme se présente comme suit :
En-tête de l’algorithme. Et un corps encore appelé bloc.
Un algorithme commence toujours par les mots réservés suivants : Algo, Algorithme ou Programme suivi de son Nom. Son nom est un identificateur ; il permet de nommer l’algorithme. Un bloc est toujours constitué d’une partie déclarative et d’une partie instruction. Il est subdivisé en quatre (04) parties :
déclaration de constantes. déclaration de types. déclaration de variables. déclaration de procédures et de fonctions.
Tous les Algorithmes doivent se terminer par : FinAlgo s’ils sont débutés par Algo. FinProgramme s’ils sont débutés par Programme. FinAlgorithme s’ils sont débutés par Algorithme.
3.2.2.1 Les identificateurs Les identificateurs sont des mots qui servent à désigner, nommer, identifier les entités, les objets, les actions, les procédures et fonctions manipulés dans un programme. Les identificateurs ne se créent pas n’importe comment. Ils doivent respecter les diagrammes syntaxiques encore appelés diagrammes de CONWAY : un identificateur débute toujours par une lettre ou un caractère de soulignement qui peut être suivi de lettres, de chiffres ou de caractères de soulignement de façon optionnelle.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
27
-
Identificateur
Lettre Départ
Lettre
-
Arrivée
Chiffre
Figure 8. Diagramme syntaxique d’un identificateur NOUATIN, Théophile.- Les bases de la PROGRAMMATION avec C++ .- ITSS SOFT page 34.
3.2.2.2 Les expressions Elles sont formées par une combinaison d’opérateurs et d’opérandes. Les opérandes peuvent être des constantes, variables, chaînes de caractères. Les opérateurs sont arithmétiques, logiques et booléens, de chaînes de caractères, d’ensemblistes etc.
3.2.2.3 Les constantes C’est un identificateur qui garde toujours la valeur qu’on lui a attribué durant tout l’algorithme. Sa valeur ne peut être modifiée. Pour déclarer une constante, il suffit de le faire précéder du mot réservé Const ou Constante, un identificateur suivi du signe égal et une expression.
3.2.2.4 Les variables Une variable est une zone mémoire où l’on peut stocker des informations identifiées par l’identificateur. Elle peut être modifiée dans le corps de l’algorithme. Une variable est déclarée via l’instruction Var ou Variable suivi de l’identificateur et du type de la variable.
3.2.2.5 Les commentaires Dans l’algorithme, pour éclaircir certains passages, l’utilisateur (le programmeur) peut y « glisser » des commentaires. Les commentaires débutent et se terminent par le symbole spécial %. Const Pi = 3.1415 % la constante Pi a toujours une valeur de 3.1415 dans tout l’algorithme %
Exemple :
Remarque : Pour afficher le symbole % au niveau de l’algorithme en tant que caractère, nous devons nécessairement le faire précéder par le signe &.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
28
3.2.3 Les opérateurs 3.2.3.1 Les opérateurs arithmétiques Opérateur + * / Div Mod ou Modulo
Signification Addition Soustraction Multiplication Division Division entière Modulo (Reste de la division entière)
3.2.3.2 Les opérateurs logiques et binaires Opérateur Pas Et Ou OuExclusif
Signification Négation Et logique Ou logique Ou Exclusif logique
Les opérandes associés à ces opérateurs peuvent être des entiers (on parle alors d’opérateurs binaires) ou des booléens (on parle d’opérateurs logiques).
3.2.3.3 Les opérateurs de chaînes de caractères Opérateur +
Signification Concaténation de deux chaînes de caractères.
Pour concaténer deux chaînes de caractères, nous utilisons l’opérateur « + ». Le résultat est du type chaîne.
3.2.3.4 Les opérateurs relationnels Opérateur = <> < > <= >=
Signification Egal Différent Inférieur à Supérieur à Inférieur ou égal à Supérieur ou égal à
Ces opérateurs fournissent toujours un résultat booléen (Vrai ou Faux).
3.2.3.5 Les opérateurs sur les pointeurs Opérateur ^
Signification Crée un pointeur sur une variable
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
29
« La notion fondamentale de pointeur est de nommer une entité (une variable) dont le contenu n’est pas une donnée de l’application, mais une adresse mémoire. A cette adresse est stockée la donnée. C’est donc un accès direct. ». BINZINGER, Thomas.- Borland DELPHI 6.CampusPress page 258.
Exemple : Type Pointeur = ^Enregistrement Enregistrement = Structure Nom : Chaîne [10] Prénom : Chaîne [15] Lien : Pointeur FinStructure
Dans cet exemple, Pointeur est un pointeur sur le type Enregistrement. Les pointeurs permettent de créer des structures dynamiques comme les listes chaînées, les arbres, etc. Le mot réservé NIL (Not In List) est utilisé pour marquer la fin de la liste.
A
A
B
C
D
C
B
K
D H E
F
NIL
G
F
E
J I
Figure 9. Arbre binaire et structure chaînée (bidirectionnelle) formées grâce aux pointeurs
Les éléments d’un arbre se nomment nœuds et ceux d’une liste cellules. Pour l’arbre, le nœud « A » représente la tête, les nœuds « B », « C », « D », « H » et « K » sont intermédiaires et les nœuds « E », « G », « I », « J » et « F » se nomment feuilles. Pour la liste chaînée, les cellules « A » et « F » représentent vice versa la tête et la queue. Les autres cellules sont appelées cellules intermédiaires.
3.2.4 Les types de données 3.2.4.1 Les entiers En algorithme, nous utiliserons ces cinq types de données. Type EntierCourt
Domaine de définition [-128, 127]
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Entier EntierLong Mot Octet
30
[-32768, 327667] [-2147483648, 2147483647] [0, 65535] [0, 255]
3.2.4.2 Les caractères Les types caractère correspondent à l’ensemble des caractères de la table ASCII. Variable Touche : Caractère
La variable Touche peut recevoir n’importe quel caractère appartenant à la table ASCII. Nous pouvons par exemple écrire : Touche = « A » Touche = ASCII (65)
3.2.4.3 Les booléens Les variables du type booléen ne peuvent recevoir que deux valeurs (Vrai ou Faux). NB : Généralement, Faux peut être codifié par 0 et Vrai par 1. Exemple : Variable FinFichier : Booléen ( . . . ) Si FDF (Ficli) = Vrai Alors FinFichier = Vrai
3.2.4.4 Les énumérés Le type énuméré permet de définir une donnée correspondant à un ensemble ordonné d’éléments ou de valeurs. Chaque élément est défini au moyen d’un identificateur. Exemple :
Type
Sexe = (Masculin, Féminin)
3.2.4.5 Les intervalles Le type intervalle permet de définir des données en fournissant simplement la borne inférieure et la borne supérieure d’un ensemble d’entiers, de chaînes de caractères ou d’éléments définis de type énuméré. Exemple : Type Chiffre = 0. . 9
3.2.4.6 Les réels Le langage Pascal met à notre disposition cinq types de réels différents. En algorithmique, nous n’utiliserons que le type réel standard. Type Réel
Domaine de définition [2.9 x 10 -39]
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
31
3.2.4.7 Les chaînes de caractères Le type chaîne de caractères permet de définir des données correspondant à une suite de caractères (appelée chaîne de caractères) dont la longueur peut être spécifiée dans la définition. Si elle n’est pas spécifiée, le système lui attribue une longueur égale à 255 caractères. Exemple :
Type Expression = Chaîne [15] Variable Phrase : Chaîne ;
Dans cet exemple, le type Expression a été spécifié comme étant un type chaîne pouvant contenir au maximum 15 caractères.
3.2.4.8 Les tableaux Le type tableau permet de définir des données composées d’un nombre fixe d’éléments ayant tous le même type. Syntaxe Générale : NomDuTableau : Tableau [IndiceMin .. IndiceMax] de TypeElements
Remarque : l’indice minimale (IndiceMin) doit toujours être positif (> 0) Définition d’un tableau à 1 dimension TYPE NomNouveauType = Tableau [indiceMin..indiceMax] de TypeElement VAR VariableTableau : NomNouveauType
Exemples : Tab1 : Tableau [1...10] de Entier Tab2 : Tableau [1...3,1...8] de Réel Tab3 : Tableau [1...5,1...5] de Caractère
Dans cet exemple, Tab1 est un vecteur de 1 à 10 éléments de type entier. Tab2 est une matrice (tableau à 2 dimensions) contenant des réels et Tab3 contient des caractères. Pour se positionner à une cellule du tableau, il suffit d’indiquer le numéro de cellule. Ce numéro commence par l’indice 1. Exemple :
Tab1 [1] = 3 Tab2 [1,1] = 3.1415 Tab3 [5,1] = « A »
Représentation physique d’un tableau de caractères Indice sur le tableau
1 M
2 B
3
4
O
D
5 J
6 S
7 Y
8
9 S
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
T
10
11
E
M
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Tab Tab Tab Tab
32
[1] = « M » [11] = « M » [3] = « O » [25] = Erreur ! Dépassement de capacité
NB : Si l’indice d’un tableau dépasse la borne maximale de sa déclaration, un message d’erreur est envoyé à l’utilisateur par le compilateur pour lui signifier que cette zone n’appartient pas au tableau. Ce phénomène peut provoquer un blocage de l’ordinateur. Néanmoins, il faut retenir que tous les langages de programmation (tous les compilateurs) ne le contrôlent pas : c’est le cas du langage C. Donc le programmeur doit être très attentif dans la manipulation des indices d’un tableau.
3.2.4.9 Les enregistrements Le type enregistrement permet de définir des données composées d’un nombre fixe ou variable d’éléments pouvant être de types différents. Chaque élément d’un enregistrement est appelé un CHAMP. Exemple :
Type SClient = Structure Nom : Chaîne [15] Prénom : Chaîne [20] Adresse : Chaîne [45] FinSturcture
A partir de ce type, nous pouvons définir une variable enregistrement comme suit : Variable
Client : SClient
Pour accéder à une valeur d’un champ, il suffit de faire précéder le nom de ce champ par l’identificateur du type enregistrement suivi d’un point. Exemple : Client.Nom = « MBODJI » Client.Prénom = « Oumar Soulé » Client.Adresse = « Golf Nord 2 Hamo3 S/33 »
3.2.4.10 Les ensembles Le type ensemble permet de définir des données représentant une collection d’objets de même type (entier, booléen, caractère, énuméré ou intervalle). Nous pouvons spécifier un ensemble vide en utilisant []. Exemple de déclaration.
Var Chiffre Lettre
: Ensemble De 0..9 : Ensemble De « A » .. « Z »
L’ensemble Lettre peut recevoir les valeurs suivantes : Lettre = [« I », « U », « O », « A », « E », « Y »]
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
33
3.2.4.11 Les fichiers Les fichiers représentent une collection de données de même type. Celles-ci peuvent être par exemple des enregistrements (structures), des entiers, des réels, etc. Les informations sont généralement stockées sur disque. On distingue 3 types de fichiers : 1. Les fichiers typés qui sont généralement des fichiers d’enregistrement. Pour déclarer un fichier de ce type, il suffit de spécifier les mots réservés FICHIER DE suivis du type d’enregistrement. Exemple :
Type SClient = Structure Nom : Chaîne [15] Prénom : Chaîne [20] FinSturcture FichClient = Fichier de SClient
Le fichier est une collection d’enregistrements de type SClient. 2. Les fichiers non typés qui, déclarés simplement en utilisant le mot réservé FICHIER, se distinguent par un accès direct aux informations stockées sur le disque. Exemple :
Type Fich = FICHIER
3. Les fichiers Texte permettent de stocker des informations de taille variable. Elles sont séparées les unes des autres par des identificateurs de fin de ligne (caractère retour chariot). Pour déclarer un fichier texte, il suffit de spécifier le mot réservé TEXTE. Exemple :
FichText : Fichier de TEXTE
Le fichier FichText est un fichier de type Texte.
3.2.4.12 Les pointeurs Le type pointeur permet de définir une variable dont la valeur est l’adresse en mémoire d’une autre variable. Pour déclarer un type pointeur, il suffit d’utiliser le symbole ^ suivi du type de la variable pointée. Dans l’exemple suivant, le type pointeur permet de créer des variables dont le contenu correspond à une adresse pointant sur un enregistrement ARTICLE. Type Pointeur = ^Article Article = Structure Information : Entier Precedent : Pointeur Suivant : Pointeur FinStructure Variable Point : Pointeur
Exemple :
La variable Point contiendra une adresse en mémoire pointant sur un enregistrement de type Article. Dans cet enregistrement, les champs Precedent et Suivant sont également du type Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
34
Pointeur. Leurs contenus respectifs seront également une adresse d’un enregistrement de type Article. Une telle définition de structure permet de créer des listes d’éléments comme ci-dessous.
Adresse précédente
Information
Adresse suivante
Figure 10. Définition d’une structure chaînée
3.2.5 Les instructions 3.2.5.1 Introduction Un algorithme se compose d’un certain nombre d’instructions. Ces dernières sont classées par catégories. Nous étudierons tout d’abord les instructions standard traitant l’information : l’assignation, la lecture et l’écriture. Ensuite, celles définissant l’ordre d’exécution d’un programme : la séquence, le choix et la boucle. Enfin nous terminerons par les sous programmes (fonctions et procédures).
3.2.5.2 L’assignation L’assignation est une instruction qui permet d’attribuer une valeur à une variable ou à un identificateur de fonction afin d’en renvoyer le résultat. Cette valeur retournée, doit être du même type que la variable. Syntaxe : ou
/ = (Expression) / := (Expression)
Exemple : A := A+1 ; ou A = A+1 Delta = B*B – 4 *A*C
3.2.5.3 Les instructions d’Entrée/Sortie Les instructions d’entrée L’instruction d’entrée Saisir. Elle offre à l’utilisateur la possibilité d’entrer plusieurs valeurs (données) dans des variables. La syntaxe générale est la suivante : SAISIR (, ,... ) Les instructions de sortie Nous avons deux types d’instructions de sortie : Afficher et AfficherLigne. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
35
L’instruction Afficher, affiche les données et reste sur la même ligne ; tandis que AfficherLigne place le curseur après l’affichage à la ligne suivante (retour chariot). Syntaxe générale : Afficher / AfficherLigne (, . . ., )
3.2.5.4 Les instructions conditionnelles Les instructions conditionnelles permettent de modifier l’ordre de la séquence d’un algorithme. Dans une séquence, les instructions sont exécutées les unes à la suite des autres sans interruption. Nous disposons de deux instructions conditionnelles : SI ... ALORS et SELON ... DE L’instruction SI … Alors (structure alternative) La structure alternative correspond à un choix entre deux possibilités. Suivant la valeur issue de la condition spécifiée dans l’instruction, l’ordinateur exécute une suite d’instructions A ou une suite d’instructions B. En aucun cas, l’ordinateur n’exécute à la fois les instructions A et les instructions B. Syntaxe générale : SI ALORS Instruction FINSI
SI Moyenne < 10 ALORS Afficher « Redouble » FINSI
Ou
Ou
SI ALORS Instruction A SINON Instruction B FINSI
SI Moyenne < 10 ALORS Afficher « Redouble » SINON Afficher « Passe » FINSI
Exemple : est une expression logique. Le choix multiple L’instruction alternative ne nous offre que deux choix possibles dépendant de la valeur d’une condition (valeur vraie ou fausse). En algorithme, nous disposons aussi d’une instruction permettant d’effectuer un choix entre plusieurs décisions. L’instruction SELON ... DE Syntaxe Générale SELON DE Cas , , : Instruction A Cas Début Instruction 1 … Instruction N Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
36
FIN CASSINON Instruction B FINSELON peut être, soit une instruction, soit un bloc d’instructions. Les comparaisons
sont effectuées au fur et à mesure en commençant par la première ; dès qu’une comparaison s’avère vraie, les instructions correspondantes sont exécutées et le programme se branche à l’instruction qui suit FINSELON (les autres comparaisons ne sont donc pas effectuées) ; si aucune comparaison ne s’avère vraie, les instructions correspondant à CASSINON sont effectuées si la clause CASSINON existe.
3.2.5.5 Les instructions répétitives Dans un programme plusieurs instructions peuvent se répéter, il serait alors plus intéressant de les écrire une seule fois et de les exécuter plusieurs fois. Cette action est ce que l’on appelle BOUCLE. En algorithmique, nous possédons trois Boucles. La boucle REPETER … JUSQUA Cette boucle permet d’exécuter les instructions comprises entre REPETER et JUSQUA jusqu'à ce que la condition du JUSQUA soit vérifiée. Syntaxe générale : REPETER Instruction 1 Instruction 2 Instruction N JUSQUA
Les instructions allant de 1 à N vont s’exécuter jusqu’à ce que la condition soit vérifiée. Mais il faut noter que cette boucle exécute au moins une fois ces instructions avant de tester la condition. La boucle TANTQUE C’est la boucle la plus utilisée en informatique. Son fonctionnement est simple. Elle exécute toutes les instructions comprises entre les mots réservés TANTQUE et FINTANTQUE tant que la condition de départ reste vérifiée. Syntaxe générale : TANTQUE FAIRE Action 1 . . . Action N FINTANTQUE
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
37
L’ordinateur commence par vérifier si la condition est vraie. Si c’est le cas, il exécute les instructions de la boucle. Si ce n’est pas le cas les instructions suivant le FINTANTQUE sont exécutées. NB : Pour éviter une boucle infinie, il faut modifier la variable du test à l’intérieur de la boucle. La boucle POUR Cette boucle permet d’exécuter un certain nombre de fois une suite d’instructions. Syntaxe générale : POUR = à FAIRE FINPOUR
L’ordinateur exécute l’instruction Borne maximale – Borne minimale +1 fois.
3.2.6 Les sous programmes 3.2.6.1 Définition Un sous programme est rédigé de façon telle que son exécution puisse être commandée par un programme. Celui-ci est appelé programme appelant. Il fournit des données au sous programme et récupère les résultats de ce dernier. On distingue deux types de sous programmes que sont les procédures et les fonctions. La différence est qu’une fonction renvoie une valeur alors qu’une procédure ne renvoie pas de valeur.
3.2.6.2 Les procédures Les procédures sont composées d’un en-tête de procédure et d’un bloc d’instructions : c’est la partie déclarative et le corps de la procédure. Syntaxe générale Procédure () Début Instruction(s) FinProcédure
L’appel d’une procédure se fait au sein du programme principal avec une instruction composée de l’identificateur de la procédure suivi des paramètres effectifs. Les paramètres permettent à un programme appelant de transmettre à un sous programme des données lors de l’appel de ce dernier.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
38
Un sous-programme est rédigé de façon à pouvoir recevoir des données du programme appelant ; cela est possible grâce aux paramètres. Ils sont appelés formels lors de la définition et effectifs lors de l’appel. Il existe deux types de paramètres : les paramètres transmis par valeur et les paramètres transmis par adresse.
3.2.6.3 Les fonctions Les fonctions sont constituées d’un en-tête de fonction et d’un bloc d’instructions : partie déclaration et corps de la fonction. Les fonctions effectuent certaines opérations avant de renvoyer un résultat ; elles sont donc appelées dans une expression. La syntaxe générale d’une fonction est la suivante : Fonction () : Début Instruction(s) = Valeur retour FinFonction
3.3 Exemples d’erreurs Il s’agit de traduire mot à mot tous les mots trouvés en Pascal. Mais avant cela, le système que nous devons mettre en place doit être en mesure de contrôler l’exactitude de la syntaxe de l’algorithme général. Ainsi plusieurs algorithmes seront indispensables pour analyser la syntaxe avant la traduction. Les exemples ci-dessous illustrent bien quelques cas d’erreurs qui pourront se glisser lors de l’écriture d’un algorithme. Exemple 1 TANTQUE a < b Instruction FINTANTQUE
A la ligne 1, la boucle TANTQUE manque un FAIRE. Donc nous devons être en mesure de le signaler à l’utilisateur par un message pour la correction. Exemple 2 SI a < b ALORS SI c > f ALORS POUR i = 1 à n FAIRE Instruction FINSI FINSI
A la ligne 3, la boucle POUR n’a pas été fermée. Par hypothèse toute structure de clauses (boucles ou conditions) telles que A = { a1, a2, a3, …, ai, …, an } est dite correcte si et seulement si toutes les ai appartenant à A sont correctement structurées. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
39
Exemple 3 SI a < b ALORS SI c > f ALORS POUR i = 1 à n FAIRE Instruction FINPOUR SINON Instruction SINON Instruction FINSI FINSI
La structure de choix SI ne peut pas avoir deux SINON. Exemple 4 SI a < b ALORS SI c > f ALORS POUR i = 1 à n FAIRE Instruction FINSI FINPOUR FINSI
Dans cet exemple, la boucle POUR doit obligatoirement être fermée par FINPOUR au lieu de FINSI. Exemple 5 Variable Aire, B, C : Entier F, Aire : Réel
L’exemple 5 montre une erreur de déclaration de la variable Aire. Cette dernière a été déclarée deux fois. On dit qu’elle a été dupliquée. Cas d’une autre erreur de duplication entre une variable globale et un nom de fonction. Variable Aire, Lg, Larg F
: Entier : Réel
Fonction Aire (longueur, largeur : entier) : Réel
Exemple 6 : 1. Afficher « Solution double 2. Afficher (« X1 = » , (-b + racine (delta) /2*a) 3. Afficher (Tab [ max (n, m] ) Dans le cas 1, les guillemets ne sont pas fermés. Dans le cas suivant, il manque une parenthèse fermante. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
40
Et dans le dernier cas, bien qu’il y ait autant de parenthèses et de crochets ouvrants que fermants, l’expression n’est pas correctement parenthésée. Ces six (6) exemples illustrent bien des cas d’erreurs qui arrivent souvent dans l’écriture d’un algorithme.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
41
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
42
3.4 Diagramme enchaînement des tâches entre l’utilisateur et le logiciel Avant de traduire l’algorithme en langage Pascal, nous devons élaborer plusieurs algorithmes (procédures et fonctions) qui se succéderont les uns après les autres jusqu'à la fin des contrôles de validité de l’algorithme général. Si l’un de ces algorithmes signale une erreur, un message d’erreur est automatiquement envoyé à l’utilisateur et la succession de ces algorithmes est arrêtée. Donc la traduction n’est effectuée que si et seulement si l’algorithme saisi par l’utilisateur respecte la structure générale d’un algorithme. Le diagramme ci-dessous illustre le dialogue qui est effectué entre le système (logiciel) et l’utilisateur lors de la traduction de l’algorithme en langage Pascal.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
D1 AnalyseCondition
T1
D2
D3
AnalyseDeclarationVariable
T2
D4
D5
AnalyseVariable
T3
D6 D7
AnalyseExpression
T4
D8
D9
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
43
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Traduction
T5
D10
CorrectionTraduction
T6
D11
LEGENDE
Tâche (procédure ou fonction) Document (texte) ou message (boîte de dialogue) envoyé à l’utilisateur
Base de données
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
44
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
45
3.5 Fiche descriptive des documents TACHES ENTREE SORTIE
N°
ROLE ET LIBELLE
D1
AlgoTexte : C’est le texte saisi par l’utilisateur. C’est l’algorithme écrit grâce à un éditeur de texte.
T1
D2
MessageErreur1 : C’est le message d’erreur envoyé à l’utilisateur pour lui signifier qu’il y a une erreur au niveau des clauses imbriquées.
-
T2
D3
AlgoTexte1 : C’est l’algorithme vérifié. Nous dirons qu’il est correctement structuré.
T2
T1
D4
MessageErreur2 : C’est le message d’erreur envoyé à l’utilisateur pour lui signifier qu’il y a une erreur de déclaration de variables.
-
T2
D5
AlgoTexte2 : C’est l’algorithme vérifié. Nous dirons que tous ses identificateurs sont correctement déclarés.
T3
T2
D6
MessageErreur3 : C’est le message d’erreur envoyé à l’utilisateur pour lui signifier qu’il y a un mot non identifié (non déclaré) au niveau de l’algorithme.
-
T3
-
3.6 Fiche descriptive des tâches
N° 1
2
3
Documents
Nom et Description AnalyseCondition : Cette fonction contrôle toutes les structures arborescentes (clauses) de l’algorithme. AnalyseDeclarationVariable :
Cette fonction analyse toutes les déclarations de variables, de types, de constantes, de procédures et de fonctions. AnalyseVariable : Cette fonction analyse tous les mots rencontrés dans l’algorithme. Tout mot doit nécessairement être identifié dans le dictionnaire ou dans le vecteur des variables (VectVar).
Entrée
Sortie
D1
D2, D3
D3
D4, D5
D5
D6, D7
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
4
5
6
ControleExpression : Cette fonction analyse toutes les expressions D7 écrites si elles sont correctement parenthésées. Traduction : Cette procédure traduit tous les mots rencontrés Dictionnaire, dans l’algorithme en utilisant le dictionnaire D9 comme base de données de traduction. CorrectionTraduction : Cette procédure corrige l’algorithme traduit. Elle y met quelques ponctuations ainsi que les D10 bibliothèques utilisées dans le fichier final en Pascal.
46
D8, D9
D10
D11
3.7 Analyse des tâches (procédures et fonctions) Nous utiliserons quelques primitives intermédiaires pour la gestion des tâches.
Fonction SSCH (Ligne : Chaîne ; Posit, N : Entier) : Chaîne Cette fonction extrait à partir de la position Posit d’une chaîne Ligne donnée N caractères. FONCTION SSCH (Ligne : Chaîne ; Posit, N : Entier) : Chaîne VARIABLE I : Entier DÉBUT SSCH = "" %initialisation SSCH à vide % SI Posit <= Longueur (Ligne) ALORS SI Posit + N > Longueur (Ligne) ALORS POUR i = Posit à Longueur (Ligne) FAIRE SSCH = SSCH + Ligne [i] FINPOUR SINON POUR i = Posit à (Posit + N) FAIRE SSCH = SSCH + Ligne [i] FINPOUR FINPOUR FINSI FINFONCTION
Fonctions RechercheMot (Ligne : Chaîne ; K : Entier) : Chaîne Cette fonction renvoie le premier mot rencontré à partir de la Kème position de la ligne d’entrée supposée existante. Nous signalons au passage qu’un mot est séparé par les caractères suivants : " " % : = ( )] [ ; + - * / < > \ ' "" ^ Fonction RecherCheMot (donnée Ligne Chaîne, Résultat Posit : Entier) : Chaîne % Cette fonction extrait tous les mots susceptibles d'être traduit d'une ligne. % Variable I : Entier % indice de parcours % Car : Caractère DÉBUT Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
47
Car = "" i = Posit RecherCheMot = "" SI i <= Longueur (Ligne) ET Longueur (Ligne) > 0 ALORS Car = SSCH (Chaîne, i, 1) SI Car Dans [" ", "%", ":", “=", “(", “)", "]", "[", ";", ",", ".", "+", “-", "*", "/", "<", “>", "\", "'", """", "^"] ALORS RecherCheMot = SSCH (Ligne, i, 1) i = i + 1 SINON TANTQUE (i <= Longueur (Ligne)) ET Car Pas (Dans [" ", "%", ":", “=", “(", “)", "]", "[", ";", ",", ".", "+", “-", "*", "/", "<", “>", "\", "'", """", "^"]) FAIRE RecherCheMot = RecherCheMot + SSCH (Ligne, i, 1) i = i + 1 SI i <= Longueur (Chaîne) ALORS Car = SSCH (Ligne, i, 1) FINSI FINTANTQUE FINSI FINSI Posit = i FINFONCTION
3.7.1 Fonction AnalyseDeclareVariable (donnée AlgoTexte) : Booléen Cette fonction vérifie la portée et la validité de l’ensemble des identificateurs déclarés au niveau de l’algorithme. Elle fera la distinction entre variable locale et variable globale, de même la différence entre un Type et une Variable. Des messages d’erreurs seront envoyés à l’utilisateur pour lui signifier qu’à la ligne « L », l’erreur « E » a été identifiée. La fonction AnalyseDeclareVariable a comme valeur retour : Vrai si les identificateurs sont correctement déclarés. Faux au cas contraire. Nous utiliserons un vecteur (un tableau à une dimension) qu’on appellera VectVar et qui portera en lui tous les identificateurs (variables, types, constantes, nom procédure, nom fonction) de l’algorithme.
3.7.1.1 Structure du vecteur VectVar Type StructDeclareVar = Structure NomVariable : Chaîne [30] Degré : Entier Nature : Chaîne [15] NumeroLigne : Entier LigneActuelle : Chaîne [255] FinStructure NomVariable
Degré
Nature
NumeroLigne
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
LigneActuelle
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
48
3.7.1.2 Description des champs de la structure StructDeclareVar NomVariable : il mémorise le nom de l’identificateur trouvé. Degré : c’est la profondeur de l’identificateur par rapport à l’algorithme. Celle-ci
nous permettra de faire la distinction entre variables locales et variables globales. Nature : identifie la nature de l’identificateur. Il en existe deux : nature « variable » et nature « type ». LigneActuelle : elle mémorise la ligne où se trouve l’identificateur.
3.7.1.3 Champs d’action de la fonction AnalyseDeclareVariable Le schéma ci-dessous nous montre les endroits qui sont « intéressés » par la fonction. C’est ce que nous appelons champ d’action. Algo MonEssai Const Max = 100 Type Enregistrement = Structure Nom : Chaîne [10] Prénom : Chaîne [15] FinStructure TabEnreg : Tableau [1..Max] de Enregistrement Variable Tab : TabEnreg I, Choix : Entier
Champs d’action
Procédure SaisirEnreg (T : TabEnreg, sortie n) Début Si n < Max Alors n = n + 1 Afficher « Nom= » ; Saisir (Tab[n].Nom) Afficher « Prénom= » ; Saisir (Tab[n].Prénom) Sinon AfficherLigne « Pas d’espace » FinSi FinProcédure Procédure AfficherEnreg (T : TabEnreg) Variable i : Entier Début Pour i = 1 à Max Faire Afficher « Nom= » ; Saisir (Tab[i].Nom) Afficher « Prénom= » ; Saisir (Tab[i].Prénom) FinPour FinProcédure Début i = 0 Repeter AfficherLigne « 1 : Ajout » AfficherLigne « 2 : Affichage » AfficherLigne « 3 : Quitter » Afficher « Choix = »
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
49
Saisir (choix) Si Choix = 1 Alors SaisirEnreg (Tab, i) FinSi Si Choix = 2 Alors AfficherEnreg (Tab) FinSi Jusqua Choix = 3 FinAlgo
Seuls les mots mis en évidence seront concernés dans cette fonction.
3.7.1.4 Analyse de la fonction AnalyseDeclareVariable L’opération d’ajout dans le vecteur VectVar se fera dans les cas suivants : A la rencontre des mots réservés Algo, Programme, Algorithme, Constante, Const, Procédure et Fonction. A la rencontre du mot réservé Type. Dans ce cas, l’opération d’ajout dans le vecteur VectVar se fera de la manière suivante : A la rencontre du premier mot suivi du Type L’opération d’ajout dans le vecteur s’arrêtera à la rencontre de « ; », de la fin de la ligne ou à la rencontre de DÉBUT. NB : Ne pas ajouter tout mot trouvé après les signes « = » et « : » car ils déclencheront la recherche de l’identificateur dans le vecteur et dans le dictionnaire. Cela veut dire que nous avons simplement rencontré un type qui est normalement défini au préalable. Exemple
Const Max1 = 50 Max2 = 100 Max = Max1 + Max2
Recherche de Max1 et Max2
Dans cet exemple, Max1 et Max2 se situent respectivement après le signe « = ». La recherche des identifiants (Max1 et Max2) au niveau de VectVar sera fructueuse car ces derniers y ont été ajoutés depuis leurs rencontres au niveau de la ligne 1 et 2. NB : Les nombres (50 et 100) ne font pas l’objet de cette recherche. Exemple : Type Etudiant = Structure ; Nom : Chaîne [10] ; Prénom : Chaîne [15] ; Matricule : Chaîne [25] ; FinStructure
Les mots doubles soulignés seront directement ajoutés au niveau du vecteur VectVar. Les mots surlignés (gris) déclencheront la recherche de ces derniers aussi bien dans le dictionnaire (Base de données) qu’au niveau du vecteur VectVar. Si cette opération de recherche est infructueuse c'est-à-dire que le mot ne se trouvant pas dans le dictionnaire et dans le vecteur, alors nous dirons que le mot rencontré n’a pas été déclaré et un message d’erreur est envoyé à l’utilisateur. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
50
Par ailleurs les mots soulignés sous-entendent qu’ils ne doivent pas au préalable exister au niveau du vecteur VectVar sinon il y a une duplication au niveau de l’identificateur et un message d’erreur est envoyé à l’utilisateur. Exemple de message d’erreur : Message (« Erreur à la ligne », l’identificateur », NomVariable)
NumeroLigne,
« Duplication
de
Chaque identifiant rencontré (type, constante, nom procédure, nom fonction) est ajouté au niveau du vecteur avec les éléments (informations) suivants : Numéro de la ligne où elle se situe. Nature : Type ou Variable. Degré : tout identificateur est ajouté au niveau du vecteur en fonction de son niveau de profondeur. Ce dernier nous permet de faire la distinction entre identificateur local et identificateur global. Le degré est incrémenté à la rencontre des mots réservés Algo, Procédure, Fonction, FinProcédure et FinFonction. Exemple : Algo MonEssai Const Max = 100 Type Etudiant = Structure Matricule : Chaîne [5] Nom : Chaîne [10] Prénom : Chaîne [15] FinStructure TFichEtudiant = Fichier de Etudiant TEnreg = Etudiant Variable Fich : TFichEtudiant Enreg : TEnreg Début ... FinAlgo
3.7.1.5 Déroulement de l’algorithme Initialisons au départ Degré à 0 (zéro) : Degré = 0 Nous rencontrons le premier mot réservé Algo, nous incrémentons alors Degré de 1 (Degré = Degré + 1) donc tout ce qui va suivre sera ajouté dans le vecteur VectVar avec un Degré qui est égal à 1 sauf si nous rencontrons Procédure, Fonction, FinProcédure et FinFonction. Et par convention tout mot (identifiant) ajouté avec un Degré = 1 est un identifiant global et ceux qui sont ajoutés avec un Degré > 1 sont locaux. Le mot suivant est MonEssai, ajoutons ce dernier à VectVar.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
51
NB : il faut noter qu’il est impossible d’ajouter deux identifiants de même nom avec le même Degré (niveau de profondeur) sinon il y a duplication d’identifiant. Voici l’état de VectVar : VectVar (1) =
MonEssai NomVariable
1
VARIABLE
Degré
Nature
1
Algo MonEssai
NumeroLigne
LigneActuelle
Fin de la ligne, nous passons à la ligne suivante et nous rencontrons à nouveau un autre mot réservé déclencheur d’empilement (Constante). Le mot suivant est Max, on réitère l’opération c'est-à-dire nous cherchons d’abord ce dernier au niveau du dictionnaire ensuite dans le vecteur VectVar. Ce dernier ne doit en aucun cas y figurer sinon il y a duplication. Passons au mot suivant, nous rencontrons « = », un signe déclencheur de recherche de « Type » dans le vecteur VectVar. Le mot suivant est 100, la recherche n’est pas effectuée car il est numérique. Fin de la ligne, passons à la ligne suivante (ligne 3), nous rencontrons le mot réservé Type qui déclenche l’opération d’ajout au niveau du vecteur si le mot se situe avant le signe « = » et de recherche si le mot se situe après ce signe. Le mot suivant est Etudiant, avant de l’ajouter dans le vecteur VectVar, nous ferons d’abord une recherche dans le dictionnaire puis dans le vecteur avec un Degré = 1 pour être sûr de son inexistence dans ces derniers. S’il n’y figure pas, nous l’empilons (ajoutons) avec son « Degré », sa « nature », son « numeroLigne » ainsi que sa « ligneActuelle ». Ce procédé continue jusqu’à ce que nous rencontrions une erreur ou que nous arrivons à la fin de l’algorithme. Exemple 2 : Algo MonEssai Variable X, Y : Entier Fonction Maximum (X, Y : Entier) : Entier Début Si X > Y Alors Maximum = X Sinon Maximum = Y FinSi FinFonction Début EffacerEcran Afficher « Valeur de x et y » Saisir (x, y) Afficher (« le plus grand des 2 nombres est », maximum (x, y)) FinAlgo
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
52
En exécutant notre algorithme, l’état du vecteur sera le suivant : Position sur le Vecteur
Etat du Vecteur
1 2 3
MonEssai
1
Variable
1 Algo MonEssai
X
1
Variable
3 X, Y
: Entier
Y
1
Variable
3 X, Y
: Entier
4 5
Maximum
1
Variable
4 Fonction Maximum (X, Y : Entier) : Entier
X
2
Variable
4 Fonction Maximum (X, Y : Entier) : Entier
6
Y
2
Variable
4 Fonction Maximum (X, Y : Entier) : Entier
NomVariable
Degré
Nature
NumeroLigne
LigneActuelle
Nous remarquons que grâce au niveau de profondeur, nous avons quatre identifiants de Degré = 1 et deux de Degré = 2. Or par convention, nous disons qu’un identificateur est global si son Degré est 1 et au cas contraire c’est un identificateur local. Donc à la position 2 et 3, les identificateurs X et Y sont des variables globales et la position 4, maximum est global malgré la rencontre du mot réservé Fonction qui incrémente le Degré. Maximum est empilé exceptionnellement avec le un Degré égal à 1 pour signifier qu’il est global. Nous utiliserons trois primitives pour écriture l’algorithme : Fonction EmpilerVariable (Nom_identifiant : chaîne ; Degré, NumLigne : entier ; TypeIdent : chaîne, Ligne : chaîne) : Booléen qui empile Nom_identifiant au niveau du vecteur VectVar avec son degré, son numéro ligne, son type (TypeIdent) et sa ligne d’instruction. Elle renvoie
la valeur Faux si l’identifiant existe (avec le même degré de profondeur) dans le vecteur et Vrai dans le cas contraire. Fonction DepilerVariable (Nom_Var, Degré) : Booléen qui vérifie si Nom_var de profondeur Degré existe au niveau de VectVar. Elle renvoie la valeur
Vrai si Nom_var y existe et Faux dans le cas contraire. Fonction RechercheInTabVar (Mot) : Booléen qui cherche Mot au niveau
du dictionnaire. Elle renvoie la valeur Vrai si la recherche est fructueuse et Faux dans le cas contraire.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
3.7.1.6 Ecriture de l’algorithme Fonction AnalyseDeclarationVariable (donnée AlgoTexte) : Booléen % cette fonction mémorise tous les variables, les constantes, les noms de procédure et de fonctions. Ainsi dans la fonction ANALYSEVARIABLE, nous ferons une cherche sur VectVar pour voir si le mot trouvé est déjà déclaré...% VARIABLE NumLigne : Entier % compteur de ligne % I : Entier Arret, BoolVar, CfVar, Trouver : Booléen % Boolvar nous permet de savoir si nous sommes sur les variables % Ligne, Mot : Chaîne Degré : Entier % c’est le niveau de profondeur de l’identificateur rencontré % ResultEmpile, InProcFonct, InType : Booléen % InType nous permet de savoir si nous sommes au niveau des types % EmpileVar, EmpileType : Booléen DÉBUT Ouvrir (AlgoTexte) en Lecture % ouverture du fichier texte en lecture % Arret = Faux NumLigne = 0 Degré = 0 Ligne = "" BoolVar = Faux CfVar = Faux TANTQUE PAS (FDF (AlgoTexte)) ET (Arret = Faux) FAIRE LireLigne (AlgoTexte, Ligne) InProcFonct = Faux NumLigne = NumLigne + 1 i = 1 CfVar = Vrai TANTQUE (i <= Longueur (Ligne)) ET (Longueur Ligne)) > 0) ET (Arret = Faux) FAIRE Mot = RecherCheMot (Ligne, i) SI (Mot Dans ["CONST", "TYPE", "VAR", "ALGO", "PROCÉDURE", "FONCTION", Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
53
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
54
"VARIABLE", "PROGRAMME", "ALGORITHME", "CONSTANTE"] ALORS BoolVar = Vrai CfVar = Vrai FINSI SI Mot Dans ["CONST", "CONSTANTE", "TYPE"] ALORS InType = Vrai SI (Mot = "VAR") OU (Mot = "VARIABLE") ALORS InType = Faux SI (Mot = "PROCÉDURE") OU (Mot = "FONCTION") OU (Mot = "ALGO") OU (Mot = "PROGRAMME") OU (Mot = "ALGORITHME") Alors Degré = Degré + 1 InType = Faux FINSI SI (Mot = "PROCÉDURE") OU (Mot = "FONCTION") Alors InProcFonct = Vrai SI (Mot = "DÉBUT") OU (Mot = "(") OU (Mot = "FINPROCÉDURE") OU (Mot = "FINFONCTION") ALORS BoolVar = Faux SI Mot = "DÉBUT" Alors InType = Faux FINSI SI (Mot = ":") OU (Mot = "=") OU (Mot = "(") Alors CfVar = Faux FINSI SI Mot = ";" ALORS CfVar = Vrai SI (Mot = "FINPROCÉDURE") OU (Mot = "FINFONCTION") ALORS Degré = Degré + 1 FINSI SI (BoolVar = Vrai) ET (CfVar = Vrai) ALORS SI Mot Pas (Dans ["VAR", "CONST", "TYPE", "FINSTRUCTURE", "VARIABLE", "CONSTANTE", "PROCÉDURE", "FONCTION", "ALGO", ";", "PROGRAMME", "ALGORITHME"]) ALORS % cherche la variable trouvée dans le vecteur VectVar % Trouver = RechercheInTabVar (Mot) SI Trouver = Vrai Alors % dans ce cas la variable a été dupliquée et on arrête aussitôt l’algorithme Arret = Vrai Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
55
SINON SI TestVariable (Mot, NumLigne) = Faux Alors % analyse la variable s’il n'est réservée % AnalyseDeclarationVariable = Faux SINON % Mémorise la variable déclarée... % SI InProcFonct = Faux Alors % si nous ne sommes pas sur la ligne procédure et fonction % SI InType = Vrai Alors ResultEmpile = EmpilerVariable (Mot, Degré, NumLigne, "TYPE", Ligne) SINON ResultEmpile = EmpilerVariable (Mot, Degré, NumLigne, "VARIABLE", Ligne) FINSI SI ResultEmpile = Faux Alors Arret = Vrai Trouver = Faux AnalyseDeclarationVariable = Faux FINSI SINON % nous sommes sur la ligne procédure et fonction donc nous empilons le nom de la procédure comme variable globale. Faisons à cet effet la recherche de ces paramètres... Ce premier mot doit donc être le nom de la procédure ou de la fonction...% ResultEmpile = EmpilerVariable (Mot, 1, NumLigne, "VARIABLE", Ligne) SI ResultEmpile = Vrai Alors Mot = RecherCheMot (Ligne, i) TANTQUE (i <= Longueur (Ligne) ET (ResultEmpile = Vrai)) ET (InProcFonct = Vrai) FAIRE SI Mot = "(" Alors EmpileVar = Vrai EmpileType = Faux FINSI SI Mot = ":" ALORS EmpileType = Vrai EmpileVar = Faux FINSI TANTQUE (EmpileVar = Vrai) ET (i <= Longueur (Ligne)) ET (ResultEmpile = Vrai) FAIRE
SI Mot PAS Dans [":", ";", ",", "(", ")", "VAR", "VARIABLE","ENTREE", "SORTIE", Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
56
"RÉSULTAT", "ES","DONNÉE"]) ALORS ResultEmpile = EmpilerVariable (Mot, Degré, NumLigne, "VARIABLE", Ligne) SI ResultEmpile = Faux Alors Arret = Vrai FINSI SI Mot = ":" Alors EmpileType = Vrai EmpileVar = Faux FINSI Mot = RecherCheMot (Ligne, i) FINTANTQUE TANTQUE (EmpileType = Vrai) ET (i <= Longueur (Ligne)) ET (ResultEmpile = Vrai) FAIRE SI (Mot Pas (Dans [":", ";", ",", "(", ")"]) Alors ResultEmpile = RechercheInTabVar (Mot) SI ResultEmpile = Faux Alors ResultEmpile = DepilerVariable (Mot, 1) SI ResultEmpile = Faux Alors Arret = Vrai FINSI FINSI FINSI SI Mot = ";" Alors EmpileType = Faux EmpileVar = Vrai FINSI SI Mot = ":" Alors EmpileType = Vrai EmpileVar = Faux FINSI Mot = RecherCheMot (Ligne, i) FINTANTQUE SI i > Longueur (Ligne) Alors InProcFonct = Faux FINTANTQUE SINON Arret = Vrai Trouver = Faux AnalyseDeclarationVariable = Faux FINSI SI ResultEmpile = Faux ALORS Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Arret = Vrai Trouver = Faux AnalyseDeclarationVariable = Faux Message "Erreur déclaration à la ligne ", NumLigne, Mot, " est non défini ! Vérifiez s'il ne doit d'abord pas être déclaré au niveau des variables types ou constantes. Ou il y a un ""DÉBUT"" qui manque
57
!"
FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINSI FINTANTQUE FINTANTQUE FermerFichier (AlgoTexte) SI Arret = Vrai Alors Message "Erreur déclaration à la ligne ", NumLigne, Mot, " est un mot réservé. Il ne peut pas être déclaré comme VARIABLE, TYPE, CONSTANTE, nom d'ALGORITHME, nom de FONCTION ou nom de PROCÉDURE. Ou il y a un ""DÉBUT"" qui manque !" FINSI AnalyseDeclarationVariable = PAS (Arret) FINFONCTION
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
58
3.7.2 Fonction DeclareVariable (donnée AlgoTexte) : Booléen Cette fonction teste tous les mots compris entre les mots réservés DÉBUT et FinAlgo ou FinProgramme ou FinAlgorithme. Ce test consiste simplement à faire une recherche du mot trouvé avec son degré dans le vecteur VectVar et au niveau du dictionnaire. En d’autres termes, cette fonction nous permet de savoir si un mot est déclaré ou pas. Si la recherche est infructueuse, alors nous dirons que le mot trouvé n’est pas déclaré et un message d’erreur est envoyé à l’utilisateur. Les mots entre guillemets et commentaires (voir structure générale d’un algorithme) sont ignorés.
3.7.2.1 Champs d’action de la fonction DeclareVariable Algo MonEssai Variable X, Y : Entier
Champs d’action
Fonction Maximum (X, Y : Entier) : Entier DÉBUT Si X > Y Alors Maximum = X Chaînes Sinon ignorées Maximum = Y FinSi FinFonction DÉBUT EffacerEcran Afficher « Valeur de x et y » Saisir (X, Y) Afficher (« le plus grand des 2 nombres est », maximum (X, Y)) FinAlgo
3.7.2.2 Analyse de la Fonction DeclareVariable Nous utiliserons le vecteur VectVar construit à partir de la fonction AnalyseDeclareVariable (vue précédemment) et le dictionnaire pour savoir si le mot trouvé a été déclaré ou pas. La fonction est déclenchée par la rencontre du mot réservé DÉBUT et ne se termine qu’à la rencontre du mot réservé FinAlgo, FinProgramme ou FinAlgorithme. Tous les mots surlignés feront l’objet de la fonction. Que fait cette dernière ? Elle fait d’abord une recherche dans le dictionnaire, si le mot ne s’y trouve pas, la recherche s’effectuera alors dans le vecteur VectVar qui garde en mémoire tous les mots (identificateurs) déclarés au niveau de l’algorithme.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
59
Si le mot ne s’y trouve toujours pas, alors un message d’erreur est envoyé à l’utilisateur pour lui signifier qu’un mot non défini a été trouvé. NB : La recherche que nous effectuons dans le vecteur VectVar tiendra compte du niveau de profondeur (Degré) vu précédemment. Le principe d’incrémentation de « Degré » est le même que celle de la fonction AnalyseDeclareVariable. On dit que les deux fonctions se synchronisent au niveau de la profondeur et du nom de l’identificateur.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
3.7.2.3 Ecriture de l’algorithme Fonction DeclareVariable (donnée AlgoTexte) : BOOLÉEN % cette fonction vérifie l'ensemble des mots-clés de l'algorithme s'ils sont déclarés ou pas. Donc chaque mot-clé doit nécessairement être déclaré au préalable... avant toute utilisation % VARIABLE NumLigne i, Degré Arret, Trouver Ligne, Mot inf, sup, milieu, j
: : : : :
ENTIER ENTIER BOOLÉEN CHAÎNE Entier
DÉBUT Ouvrir (AlgoTexte) en Lecture Arret = FAUX NumLigne = 0 Ligne = "" Degré = 0 TANTQUE PAS (FDF (fichier)) ET (Arret = FAUX) FAIRE LireLigne (AlgoTexte, Ligne) NumLigne = NumLigne + 1 % incrémente l’indice de la ligne à chaque lecture d’une ligne % i = 1 TANTQUE (i <= Longueur (Ligne)) ET (Longueur (Ligne) > 0) ET (Arret = FAUX) FAIRE Mot = RecherCheMot (Ligne, i) SI (Mot PAS (Dans ["", " ", ">", "\", "-", "*", "+", "/", "=", ")", """", "&", ",", "^", ":", ";", "(", "]", "[", ".", "'", "<"])) ALORS SI (Mot Dans ["PROCÉDURE", "FONCTION", "ALGO", "PROGRAMME", "ALGORITHME", "FINPROCÉDURE", "FINFONCTION") ALORS Degré = Degré + 1 FINSI inf = 1 Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
60
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
61
sup = Pos milieu = Int ((inf + sup) / 2) Trouver = FAUX % recherche dichotomique de la variable sur la liste des mots susceptibles d'être traduits... % TANTQUE (inf <= sup) ET (Trouver = FAUX) FAIRE % Parcours du TABLEAU % milieu = (inf + sup) div 2 SI Mot > Tableau (milieu).Algorithme ALORS inf = milieu + 1 SINON SI Mot = Tableau (milieu).Algorithme ALORS % le mot est trouvé % Trouver = VRAI SINON Sup = milieu - 1 FINSI FINSI FINTANTQUE SI Trouver = FAUX ALORS % Nous dépilons toutes les variables déclarées pour voir s'il est déclaré... % SI DepilerVariable (Mot, Degré) = VRAI ALORS Trouver = VRAI FINSI SI Trouver = FAUX ALORS % mais il faut noter que la chaîne trouvée peut être constituée de nombres, alors il sera considérée comme déclarée, sinon non déclarée % POUR j = 1 à Longueur (Mot) FAIRE Selon SSCH (Mot, j, 1) De Cas "0", "1", "2", "3", "4", "5", "6", "7", "8", "9" Trouver = VRAI Cas SINON Trouver = FAUX Arret = VRAI Exit POUR FINSELON FINPOUR FINSI SI (Trouver = FAUX) ET (Mot Pas (Dans ["""", ";", ":", "", "'"])) ALORS Message "ERREUR DECLARATION ! à la ligne ", NumLigne, "." , Mot ," non défini à la ligne" "LIGNE ERREUR --> ", Ligne, "Vérifier s'il ne s’agit pas de variable, TYPE," "nom PROCÉDURE ou nom de FONCTION non définis..." AnalyseVariable = FAUX Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Arret = VRAI FINSI FINSI FINSI FINSI FINTANTQUE FINTANTQUE FermerFichier (AlgoTexte) AnalyseVariable = PAS (Arret) FINFONCTION
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
62
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
63
3.7.3 Fonction AnalyseCondition (donnée AlgoTexte) : Booléen Cette fonction contrôle toutes les structures arborescentes (clauses) de l’algorithme. Elle renvoie la valeur : Vrai si elle est correctement structurée. Faux au cas contraire. Nous dirons qu’une clause arborescente « A » est correctement structurée si toutes les sousstructures arborescentes « ai » appartenant à A sont correctement structurées.
3.7.3.1 Clause d’ouverture et clause de fermeture Une clause d’ouverture doit nécessairement être fermée par une et une seule clause de fermeture. Clause d’ouverture Algo Programme Algorithme Structure Procédure Fonction Si Tantque Pour Repeter Selon
Clause de fermeture FinAlgo FinProgramme FinAlgorithme FinStructure FinProcédure FinFonction FinSi FinTantque FinPour Jusqua FinSelon
Par ailleurs certaines clauses nécessitent un ou plusieurs mots réservés pour leurs fonctionnements : Si (condition) Alors Tantque (condition) Faire Pour nom_var = valeur_min à valeur_max Faire Selon nom_var De
NB : Il faut savoir qu’il existe des sous-clauses qui sont toujours utilisées entre une clause d’ouverture et une autre de fermeture, mais leur usage n’est pas obligatoire. La sous-clause SINON Si (condition) Alors Action
Sinon Action FinSi
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
64
La sous-clause CasSinon Selon nom_var De Cas Valeur : Action
CasSinon Action FinSelon
NB : L’union d’une clause d’ouverture et d’une clause de fermeture est appelée « Structure arborescente ». Les structures arborescentes Si-Finsi et Selon-FinSelon ne peuvent avoir au plus qu’une sous-clause. Néanmoins une structure arborescente peut imbriquer plusieurs sous structures arborescentes. Exemple Algo Nom_Algo Var Liste_Var : Type Début Si (condition) Alors Tantque (condition) Faire Pour nom_var = min à max Faire Repeter Action Jusqua (condition) FinPour FinTantque Sinon Repeter Selon nom_Var De Cas Valeur_nom_var : Action CasSinon Si (condition) Alors Action FinSi FinSelon Jusqua FinSi FinAlgo
3.7.3.2 Outils utilisés pour le contrôle des structures arborescentes Nous utiliserons une pile pour garder en mémoire l’état de toutes les clauses d’ouverture de l’algorithme.
3.7.3.3 Structure de la pile Type EnregPile = Structure Condition : Chaîne [12] Validité : Booléen NumLigne : Entier Sinon : Entier FinStructure Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
65
3.7.3.4 Description des champs de la structure Condition Validité NumLigne Sinon
: mémorise le nom de la clause empilée. : vaut Vrai si la condition (clause) n’est pas fermée. Faux au cas contraire. : mémorise le numéro de la ligne où se trouve la clause rencontrée. : voici les différents cas possibles : (-1) si la clause ne possède jamais de SINON (sous-clause). C’est le cas de TANTQUE, REPETER, POUR, PROCÉDURE, FONCTION etc. (0) si la clause ne possède pas encore de SINON. (1) si la clause possède un SINON.
3.7.3.5 Analyse de la fonction AnalyseCondition Cette fonction utilise une pile de 300 enregistrements au maximum. Elle empile (ajoute) au niveau de la pile toutes les clauses ouvrantes précédemment vues avec Validité = Vrai. Ceci nous permettra d’imbriquer des sous-structures. A la rencontre d’une clause fermante, nous ferons un retour en arrière à partir du SOMMET pour trouver la première clause valide correspondante (Validité = Vrai). Néanmoins, lors du retour en arrière, toutes les clauses que nous rencontrerons au passage avant la clause cherchée doivent nécessairement être invalides (fermées) c'est-à-dire Validité = Faux. Dans tous les cas, à chaque lecture d’une ligne, nous incrémenterons la variable ligne et nous l’empilerons avec sa clause correspondante. Ceci nous permettra de signaler à l’utilisateur qu’une erreur a été détectée à une ligne donnée. Exemple : SI (Condition) ALORS TANTQUE (Condition) FAIRE REPETER Action JUSQUA (condition) FINTANQUE SINON POUR nom_var = min à max FAIRE Action FINPOUR FINSI
Dans cet exemple, les clauses ouvrantes sont SI, TANTQUE, REPETER et POUR et les clauses fermantes sont JUSQUA, FINTANTQUE et FINSI.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
66
Etat de la pile par la lecture ligne par ligne de l’exemple : Condition Ligne 1
Validité
SI
NumLigne
VRAI
1
Sinon 0
La clause rencontrée est « SI », elle est valide. Elle se trouve à la ligne n°1 et ne possède pas de « SINON » Ligne 2
TANTQUE
VRAI
2
-1
SI
VRAI
1
0
A la ligne suivante, nous rencontrons la clause « TANTQUE » qui ne possède jamais de « SINON ». Ligne 3
REPETER
VRAI
3
-1
TANTQUE
VRAI
2
-1
SI
VRAI
1
0
A la 3ème ligne, nous rencontrons la clause ouvrante « REPETER » que nous empilons aussi. Ligne 5
REPETER
FAUX
3
-1
TANTQUE
VRAI
2
-1
SI
VRAI
1
0
Nous rencontrons la première clause fermante (JUSQUA) de « REPETER », donc nous faisons un retour en arrière à partir du SOMMET jusqu'à ce qu’on trouve le premier « REPETER » valide que nous invaliderons (Validité = Faux). Ligne 6
REPETER
FAUX
3
-1
TANTQUE
FAUX
2
-1
SI
VRAI
1
0
Nous trouvons à nouveau une clause fermante « FINTANQUE » à la ligne 6, depuis le SOMMET de la pile, nous cherchons le premier TANTQUE valide que nous mettrons par la suite à Faux. Ligne 7
REPETER
FAUX
3
-1
TANTQUE
FAUX
2
-1
SI
VRAI
1
1
A la ligne 7, nous rencontrons le « SINON ». Ainsi nous cherchons le premier « SI » valide n’ayant pas de « SINON » (Sinon = 0) partant du SOMMET. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Ligne 8
POUR
VRAI
8
-1
REPETER
FAUX
3
-1
TANTQUE
FAUX
2
-1
SI
VRAI
1
1
67
A la ligne 8, la clause « POUR » est rencontrée, on l’empile directement au SOMMET de la pile.
Ligne 10
POUR
FAUX
8
-1
REPETER
FAUX
3
-1
TANTQUE
FAUX
2
-1
SI
VRAI
1
1
« FINPOUR » est rencontrée à la 10ème ligne. Nous mettons la clause « POUR » à FAUX. NB : Si l’algorithme s’achevait ici, il y aurait une erreur car toutes les clauses ne sont pas fermées. C’est le cas du « SI » qui se situe au bas de la pile. Ainsi à la 11ème ligne l’état de la pile est la suivante :
Ligne 11
POUR
FAUX
8
-1
REPETER
FAUX
3
-1
TANTQUE
FAUX
2
-1
SI
FAUX
1
1
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
3.7.3.6 Ecriture de l’algorithme FONCTION AnalyseCondition (donnée AlgoTexte) : BOOLÉEN % Cette fonction contrôle toutes les structures arborescentes (clauses) à l’aide d’une pile % Type EnregPile = Structure Condition : Chaîne [12] Validité : Booléen NumLigne : Entier Sinon : Entier FinStructure CONSTANTE MaxPile = 300 % Taille maximale de la pile % VARIABLE Pile : TABLEAU [1..MaxPile] de EnregPile FinAlgorithme : Booléen J : Entier Condition : Chaîne SOMMET : Entier % c’est le sommet de la pile % Indice : Entier % c’est l’indice sur la ligne lue % Ligne : Chaîne % c’est la ligne lue depuis le fichier AlgoTexte % CTLigne : Entier % Compteur de ligne % Début Ouvrir (AlgoTexte) en Lecture I = 0 FinAlgorithme = Faux SOMMET = 0 CTLigne = CTLigne + 1 TANTQUE Pas (FDF (AlgoTexte)) FAIRE % Tant que AlgoTexte n’est pas terminé % Indice = 1 LireLigne (AlgoTexte, Ligne) % lit une ligne entière % TANTQUE (indice <= Longueur (Ligne)) ET (FinAlgorithme = FAUX) FAIRE Condition = RechercheMot (Ligne, Indice) SI Condition Dans [« TANTQUE », « REPETER », « SI », « ALGO »,« PROCÉDURE », « FONCTION », « SELON », « ALGORITHME », « STRUCTURE », « AVEC »] ALORS SI SOMMET = MaxPile Alors % si la pile est pleine,on arrête l’algorithme % Message "Pile Pleine !" AnalyseCondition = Faux Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
68
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
69
SINON SOMMET = SOMMET + 1 FINSI Pile (SOMMET).Condition = Condition Pile (SOMMET).NumLigne = CTLigne Pile (SOMMET).Validité = Vrai SI Condition = « SI » ou Condition = « SELON » ALORS Pile (SOMMET).Sinon = 0 SINON Pile (SOMMET).Sinon = -1 FINSI FINSI % Dans le cas des clauses fermantes, nous ferons un retour en arrière pour chercher la première clause correspondante valide. Par ailleurs, lors du retour en arrière, toutes les clauses rencontrées doivent nécessairement être invalides (Validité = Faux) % Si Condition Dans [« FINTANTQUE », « JUSQUA », « FINSI », « FINALGO », « FINPROCÉDURE », « FINFONCTION », « FINSELON », « FINSTRUCTURE », « FINAVEC », « FINPROGRAMME », « FINALGORITHME »] ALORS J = SOMMET TANTQUE (J > 0) ET (FinAlgorithme = Faux) FAIRE SI Pile (J).Condition = SSCH (Condition, 4, Longueur (Condition) ALORS SI Pile (J).Validité = Vrai ALORS Pile (J).Validité = FAUX SINON J = J – 1 FINSI SINON SI Pile (J).Validité = Vrai ALORS Message « Erreur à la ligne », Pile (J).NumLigne « il faut fermer la condition », Pile (J).Condition, « avant la condition », Condition FinAlgorithme = Vrai SINON J = J – 1 FINSI FINSI FINTANTQUE FINSI % De même, à la rencontre d’un « SINON », nous ferons un retour en arrière pour chercher au niveau de la pile le premier SI valide n’ayant pas de SINON (SINON = 0). Dans le cas où nous rencontrons un SI avec (SINON = 1), alors un message est envoyé à l’utilisateur car un SI ne peut avoir au plus un SINON. % Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
SI Condition = « SINON » ALORS J = SOMMET TANTQUE (J > 0) ET (FinAlgorithme = Faux) FAIRE SI Pile (J).Condition DANS [« SI », « SELON »] ALORS SI Pile (J).Validité = Vrai ALORS SI Pile (J).SINON = 1 ALORS Message « Erreur à la ligne », Pile (J).NumLigne, « ce SI possède déjà un SINON » FinAlgorithme = VRAI SINON Pile (J).SINON = 1 FINSI SINON J = J - 1 FINSI SINON SI Pile (J).Validité = Vrai ALORS Message « Erreur ! la clause », Pile (J).Condition, « ne doit pas posséder de SINON » FinAlgorithme = VRAI SINON J = J – 1 FINSI FINSI FINTANTQUE FINSI FINTANTQUE % fin de la ligne lue % FINTANTQUE % fin du fichier AlgoTexte % % à la fin de l’algorithme, il faut être sûr que toutes les clauses ouvertes sont fermées % J = SOMMET TANTQUE (FinAlgorithme = Faux) ET (J > 0) FAIRE SI Pile (J).Validité = VRAI ALORS Message « Erreur ! à la ligne », Pile (J).NumLigne , « la clause », Pile (J).Condition, « n’a pas été fermée » FinAlgorithme = VRAI SINON J = J – 1 FINSI FINTANTQUE AnalyseCondition = PAS (FinAlgorithme) FermerFichier (AlgoTexte) % fermeture du fichier principal % FINFONCTION Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
70
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
71
3.7.4 Fonction ControleExpression (donnée AlgoTexte) : Booléen Il nous est amené de contrôler la validité d’une expression parenthésée. Une expression parenthésée est dite valide si et seulement si elle est correctement parenthésée. Nous distinguons deux types de parenthèses :
-
parenthèses ouvrantes : (,
[ et { - parenthèses fermantes : ), ] et } Chaque type de parenthèse ouvrante est toujours associé à une et une seule autre parenthèse fermante.
3.7.4.1 Liste de parenthèses Parenthèse ouvrante
Parenthèse fermante correspondante
(
)
{
}
[
]
3.7.4.2 Analyse de la fonction ControleExpression Nous ferons usage d’une pile pour garder en mémoire l’état des parenthèses ouvrantes. L’opération d’empilement se fera à chaque fois que nous rencontrons une parenthèse ouvrante et l’opération de dépilement s’effectuera à la rencontre de parenthèses fermantes. La fonction renvoie donc la valeur VRAI si toutes les lignes de l’algorithme sont correctement parenthésées et la valeur FAUX dans ces trois cas de figure : si la valeur du sommet de la pile ne correspond pas à la parenthèse fermante associée. si à la fin d’une ligne donnée et qu’au niveau de la pile il reste toujours des éléments. (la pile n’est pas vide). si la pile est vide et qu’il reste dans l’expression des parenthèses fermantes.
3.7.4.3 Exemple d’erreur dans une expression Exemple 1 : ( ( a + b ) – [ k + r ) )
Le crochet ouvrant est mal fermé. Exemple 2 :
)a+b)–[k+r]
La première parenthèse fermante ne ferme aucune parenthèse ouvrante. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Exemple 3 :
72
((a+b)–k+r
A la fin de l’expression, la pile ne sera pas vide. Donc il y a une parenthèse ouvrante non fermée.
3.7.4.4 Structure de la pile Type PileParenthese = Tableau [1 . . 100] de caractère
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
3.7.4.5 Ecriture de l’algorithme Fonction ControleExpression (donnée AlgoTexte) : BOOLÉEN VARIABLE Pile : PileParenthese i, j : Entier Correct : BOOLEEN ; Ligne : CHAÎNE DÉBUT Correct = VRAI ; j = 0 Ouvrir (AlgoTexte) en Lecture TANTQUE (PAS (FDF (AlgoTexte)) ET (Correct = VRAI)) FAIRE LireLigne (AlgoTexte, Ligne) i = 1 TANTQUE (i <= Longueur (Ligne)) ET (Correct = VRAI) FAIRE SI Ligne [i] DANS [«(», «[», «{»] ALORS j = j +1 Pile [j] = Ligne [i] SINON SI (Ligne[i] Dans [«)», «]», «}»] ALORS SI j = 0 ALORS Correct = FAUX SINON SI (Ligne[i] = «)») ET (Pile [j]= «(») OU (Ligne[i] = «]») ET (Pile[j]= «[») OU (Ligne [i] = «}») ET (Pile [j]= «{») ALORS j = j – 1 SINON Correct = FAUX FINSI FINSI FINSI FINSI i = i + 1 FINTANTQUE FINTANTQUE SI j > 0 ALORS % Si la pile n’est pas vide à la fin de la ligne % Correct = FAUX FINSI ControleExpression = Correct FINFONCTION Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
73
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
74
3.7.5 Procédure Traduction (donnée AlgoTexte) Avec les fonctions précédemment vues, nous pouvons dire que l’écriture de l’algorithme est correcte si et seulement si le texte saisi par l’utilisateur respecte toutes les fonctions antérieures. Avant de traduire l’algorithme, toutes ces fonctions doivent retourner comme résultat VRAI. (Voir Diagramme enchaînement des tâches). Pour accélérer le traitement, nous porterons tous les enregistrements de la base de données dans un vecteur (tableau à 1 dimension) dont la structure est la suivante : Type Dico = STRUCTURE NomAlgo : Chaîne [15] NomPascal : Chaîne [15] Unit : Chaîne [8] FINSTRUCTURE Constante MaxDico = 500 Variable Dictionnaire : Tableau [1..MaxDico] de Dico
Maintenant, il suffit de parcourir la base de données du début à la fin et porter tous les enregistrements au niveau du vecteur Dictionnaire. Analyse : La traduction se fera essentiellement mot à mot. Nous utiliserons la fonction RechercheMot qui va extraire tous les mots contenus dans l’algorithme. Ainsi pour chaque mot trouvé, nous le remplacerons par sa désignation en Pascal depuis le vecteur Dictionnaire en Pascal s’il y existe. Sinon, il restera toujours le même. Cette recherche sur le vecteur se fera à l’aide d’une recherche dichotomique dont le principe réside sur la division successive de l’espace de recherche en deux dans un vecteur ordonné sur le critère de recherche.
3.7.5.1 Fonctions intermédiaires Fonction EnPASCAL (donnée MotAlgo : Chaîne) : Chaîne Variable Trouver : Booléen Inf, Sup, Milieu : Entier Début Inf = 1 Sup = Max EnPascal = MotAlgo % initialisation du résultat de la fonction % Trouver = Faux TANTQUE (Trouver = FAUX) ET (Inf <= Sup) FAIRE Milieu = (Inf + Sup) div 2 SI MotAlgo > Dictionnaire [Milieu].NomAlgo ALORS Inf = Mileu + 1 SINON SI MotAlgo < Dictionnaire [Milieu].NomAlgo ALORS Sup = Milieu – 1 SINON Trouver = VRAI EnPascal = Dictionnaire [Milieu].NomPascal FINSI Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
75
FINSI FINTANQUE FINFONCTION
A la sortie de cette fonction, nous aurons la signification de chaque mot algorithmique en Pascal. Par ailleurs dans cet algorithme, nous utiliserons la petite primitive EmpilerLibrairie qui mémorisera toutes les librairies utilisées dans l’algorithme. Son utilité sera très importante pour l’exécution de l’algorithme par l’ordinateur via le compilateur Turbo Pascal. Cette primitive agira comme un éditeur des liens qui regroupera toutes les bibliothèques qui seront utilisées pour l’écriture d’un algorithme. Procédure EmpilerLibrairie (donnée Librairie : Chaîne) Variable Trouver : Booléen I : Entier Début Trouver = FAUX I = 1 % Nous cherchons si la librairie n’a déjà pas été empilée % TANTQUE (Trouver = FAUX) ET (I <= PosMax) FAIRE % la variable PosMax est le sommet de la Pile % SI Librairie = VectLibrairie [I] ALORS Trouver = VRAI SINON I = I + 1 FINSI FINTANQUE SI I = PosMax Alors Message « Pile pleine » SINON SI Trouver = FAUX ALORS PosLib = PosLib + 1 VectLibrairie [PosLib] = Librairie FINSI FINSI FINPROCÉDURE
3.7.5.2 Ecriture de l’algorithme PROCÉDURE Traduction (Donnée AlgoTexte; Résultat PascalTexte) % cette procédure traduit mot à mot l'algorithme en Pascal % VARIABLE i : Entier Mot, Ligne, LigneTraduite, DernierMot : Chaîne DÉBUT OuvrirEcriture (PascalTexte) OuvrirLecture (AlgoTexte) TANTQUE PAS (FDF (AlgoTexte)) FAIRE LireLigne (AlgoTexte, Ligne) LigneTraduite = « » i = 1 TANTQUE (i <= Longueur (Ligne)) ET (Longueur (ligne) >= 1) FAIRE Mot = RechercheMot (ligne, i) DernierMot = Mot LigneTraduite = LigneTraduite + EnPascal (Mot) FINTANTQUE % fin de la ligne % Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
76
SI DernierMot = "SINON" ALORS EcrireLigne (PascalTexte, "END") FINSI EcrireLigne (PascalTexte, LigneTraduite) % Ecrire la ligne traduite en PASCAL si le dernier mot est égal à ALORS, SINON, type, etc. % SI (DernierMot PAS DANS ["DO", "ALORS", "SINON", "TYPE", "CONST", ";", "VAR"]) ALORS SI Longueur (LigneTraduite) > 0 ALORS SI DernierMot PAS DANS [";", ".", "}"] ALORS EcrireLigne (PascalTexte, LigneTraduite + " ;") SINON EcrireLigne (PascalTexte, LigneTraduite) FINSI SINON EcrireLigne (PascalTexte, "") FINSI SINON EcrireLigne (PascalTexte, LigneTraduite) FINSI % test du dernier mot pour pouvoir ajouter "BEGIN" % SI DernierMot DANS ["ALORS", "SINON", "FAIRE"] ALORS EcrireLigne (PascalTexte, "BEGIN") FINSI FINTANTQUE % fin du fichier % FermerFichier (AlgoTexte) FermerFichier (PascalTexte) FINPROCÉDURE
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
77
Les différents algorithmes vus précédemment sont utilisés pour la conception du logiciel traducteur d’algorithmes en langage Pascal. Ce dernier se nomme MSAlgoPascal®. Pour améliorer l’interface utilisateur, Microsoft® Visual Basic 6.0 a été utilisé lors de la conception de MSAlgoPascal®.
4.1 Configuration requise Pour une meilleure utilisation du logiciel MSAlgoPascal®, vous devez disposer de : Processeur : PC Pentium 100 MHz au minimum Système d’exploitation : Parfaitement compatible sur toutes les versions de Windows® sous 32 Bits (Windows 95, Windows 98, Windows NT, Windows Millenium, Windows 2000 et Windows XP). Ram (mémoire vive ou centrale) : 32 Mo. Définition de l’écran : minimum 256 couleurs. Espace disque : 3.5 Mo espace disque. Périphérique : Carte son et un lecteur de cd-rom.
4.2 Installation de MSAlgoPascal Le logiciel MSAlgoPascal® est livré sur cd-rom. Insérez le cd-rom d’installation dans votre lecteur, puis patientez un moment. Cette fenêtre s’affichera en premier lieu.
Cliquez sur le bouton Installer, pour démarrer l’installation du logiciel MSAlgoPascal®. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
78
Au clic, voici la fenêtre qui s’affiche.
Cliquer sur le bouton OK Une nouvelle fenêtre se présente et vous demande de choisir votre répertoire d’installation. Pour son bon fonctionnement, MSAlgoPascal® doit être installé dans le répertoire C:\ALGOPAS.
Validez toutes ces opérations en cliquant sur le bouton suivant : Vous êtes à présent au bout, la copie des fichiers se lance automatiquement. Patientez jusqu’à ce que la barre des pourcentages soit à 100 %.
Enfin terminé, tous les fichiers sont désormais dans votre disque dur, vous pouvez maintenant retirer le cd-rom d’installation de MSAlgoPascal® de votre lecteur. Cliquez sur le bouton Démarrer de Windows, ensuite sur Tous les programmes (pour les autres versions de Windows (Win9x, WinNT, 2000) vous avez « programmes » au lieu de « Tous les programmes ») puis sur le groupe de Travail MSAlgoPascal et enfin MSAlgoPascal.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
79
®
Lancement de MSAlgoPascal depuis le menu démarrer
4.3 Pas à pas sur MSAlgoPascal® Vous avez enfin installé MSAlgoPascal®. Vous pouvez lancer MSAlgoPascal® à tout moment depuis le menu démarrer de Windows. Cette fenêtre s’affichera en premier lieu :
Chargement de la base de données en mémoire centrale
Cette fenêtre d’animation s’affiche pour une petite durée, elle charge la base de données (dictionnaire) en mémoire. (Voir III Conception Générale).
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
80
A la fin du traitement, la fenêtre principale s’affichera à l’écran.
Interface de MSAlgoPascal®
Cette fenêtre présente l’environnement général. Elle contient une barre d’outils avec des boutons sur la partie supérieure de la fenêtre et une zone de texte sur la partie gauche. C’est à partir de cette zone de texte (éditeur de texte) que l’utilisateur saisit son algorithme.
4.3.1 Comment écrire un algorithme ? L’écriture d’un algorithme est très simple. MSAlgoPascal® dispose d’un éditeur de texte standard que l’utilisateur utilise pour saisir ses algorithmes. Cette zone de texte est similaire à Bloc-notes de Windows. Par défaut, un bout de code est affiché pour préparer l’algorithme à venir. ALGO Nom_Algo DÉBUT FINALGO
Pour saisir un algorithme, l’utilisateur peut changer le nom Nom_Algo par le nouveau nom qu’il introduit, ensuite déclarer les variables, types, constantes si nécessaire. Puis entre le Début et FinAlgo, il introduira les instructions de l’algorithme principal.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
81
4.3.2 Présentation des objets de l’environnement 4.3.2.1 La barre d’outils
Le logiciel MSAlgoPascal® dispose d’une barre d’outils assez complète qui permet à l’utilisateur de dialoguer avec le système. Le bouton Nouveau
Il sert à créer de nouveaux algorithmes. L’ordinateur affiche une page vierge et invite l’utilisateur à saisir son nouvel algorithme. Le bouton Ouvrir
Ce bouton nous permet d’accéder au répertoire des fichiers d’algorithme sauvegardés sur le disque dur et de les ouvrir. A son clic, voici la fenêtre qui s’affiche.
L’utilisateur peut sélectionner l’un des algorithmes précédemment sauvegardés pour l’éditer à nouveau.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
82
Après sélection, voici l’apparence de la fenêtre principale.
Le bouton Enregistrer
Le bouton Enregistrer sert à sauvegarder l’algorithme courant dans le disque dur. Si l’algorithme porte déjà un nom, le fichier source est automatiquement mis à jour selon les modifications effectuées. Mais s’il s’agissait d’un nouvel algorithme, une fenêtre d’enregistrement s’afficherait et inviterait à nouveau l’utilisateur à donner un nom à l’algorithme. Cette fenêtre d’enregistrement se présente ainsi :
L’utilisateur est appelé à donner un nom de fichier n’ayant pas plus de 8 caractères (à cause du système de gestion de fichier sur MS-DOS). Ce fichier ne doit comporter ni de caractères spéciaux ni d’espaces. Une fois saisi, nous cliquons sur le bouton Enregistrer pour valider cette opération.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
83
Le bouton Imprimer
Ce bouton permet à l’utilisateur d’imprimer ses codes sources (aussi bien l’algorithme que sa traduction en langage Pascal). A son clic, une fenêtre s’affiche et l’invite à choisir le code à imprimer. La fenêtre d’invite se présente ainsi :
Le bouton Dictionnaire
Il est très important et permet d’accéder à la base de données du système (voir Schéma relationnel (voir 3.1.4 Implémentation du modèle conceptuel des données). A son clic, la fenêtre de relation s’affiche. Les données sont triées en ordre croissant sur l’algorithme.
A chaque clic sur un enregistrement (occurrence), le système pointe automatiquement sur l’enregistrement auquel il correspond. Par exemple, en cliquant sur ALGO, l’ordinateur sélectionne sur les mots listés en Pascal PROGRAM et un vide sur la liste des Librairies. Cela veut simplement dire que ALGO en algorithme signifie PROGRAM en Pascal et son utilisation ne nécessite pas de librairie.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
84
Le bouton Zoom
Il permet d’agrandir l’algorithme ou la traduction en plein écran et facilite l’écriture de l’algorithme.
Zoom sur l’algorithme
Le bouton Gestion de l’interface de l’environnement
La gestion de l’interface de l’environnement permet à l’utilisateur de personnaliser l’interface générale. Cette fenêtre s’affiche par la suite :
Gestionnaire des couleurs de l’environnement
Grâce à cette fenêtre l’utilisateur peut changer la couleur de la police, la couleur de fond et de l’environnement. Cette fenêtre permet aussi de changer le type de police et la taille de tabulation. Pour conserver ces modifications, il suffit de cliquer sur le bouton Mémoriser. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
85
A chaque redémarrage du logiciel, MSAlgoPascal® conserve les dernières modifications de la Gestion de l’interface de l’environnement. Le bouton Traduire en langage Pascal
Pour traduire notre algorithme en langage Pascal, il suffit de cliquer sur ce bouton. C’est ce dernier qui déclenche l’ensemble des procédures et des fonctions vues antérieurement pour avoir une traduction correcte. Plusieurs messages d’erreur peuvent être envoyés à l’utilisateur pour qu’il puisse les corriger. En voici quelques exemples :
Exemple 1 Algo exemple1 Var A, b : entier Début Saisir (a1) Saisir (b) Finalgo
La variable a1 n’a pas été définie.
Exemple 2 Algo exemple2 Var A : entier Début A = 20 Tantque A > 0 Faire Afficher (« A= », A) A = A – 1 FinAlgo
La clause ouvrante Tantque n’a pas été fermée.
Exemple 3 Algo exemple3 Var K : entier Début A1 = 0 Tantque A <= 20 Faire Afficher (K) ; K = K +1 FinTantque FinAlgo
A1 est non identifié
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
86
Exemple 4 Algo Exemple4 Var 1A : entier Début Sasir (1A) Si 1A = 0 alors Afficher « un nombre nul » Finsi FinAlgo
Une variable ne doit pas débuter par 1 2 3 4 5 6 7 8 9 0 + - * / ^ ( )
Exemple 5 Algo Exemple5 Var a, b, c : entier Début Saisir (a, b, c) Afficher (« (a+b) / c = », (a+b/c) FinAlgo
Expression mal parenthésée
Une fois que l’algorithme est correct, le système affiche sa traduction en langage Pascal dans la zone de texte située à droite de votre algorithme de sorte que nous puissions mieux voir la traduction.
Traduction d’un exemple d’algorithme en langage Pascal
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
87
Le bouton Exécuter en langage Pascal
MSAlgoPascal® est muni du compilateur de Borland Turbo Pascal 7.0. Celui-ci nous permet d’éditer et d’exécuter nos algorithmes traduits en langage Pascal. Au clic de ce bouton, la fenêtre du compilateur Turbo Pascal 7.0 s’affiche.
Traduction de l’algorithme éditée à partir de l’éditeur de Borland Turbo Pascal 7.0
A partir de Turbo Pascal 7.0, l’utilisateur pourra exécuter ses programmes en appuyant simultanément sur les touches CTRL + F9. Voici ce que nous aurons lors de l’exécution d’un algorithme par Turbo Pascal.
Exécution du programme
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
88
Le bouton Aide
Pour savoir comment écrire un algorithme correct, il suffit de cliquer sur ce bouton. Une aide s’affiche et nous explique comment faire.
Fenêtre d’aide
4.3.2.2 Autres options du logiciel MSAlgoPascal® Opération d’ajout Il peut arriver qu’un mot ne soit pas traduit par MSAlgoPascal®, il faut donc ajouter ce dernier dans le dictionnaire et donner son équivalence en Pascal ainsi que la librairie associée. Pour ce faire, cliquer sur le menu « Dictionnaire » puis « ajouter un mot clé… »
Ainsi la fenêtre d’ajout s’affiche par la suite.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
89
Fenêtre d’ajout d’un mot dans le dictionnaire
Dans cet exemple, le mot EffacerMoniteur a été ajouté et son équivalence en Pascal n’est rien d’autre que CLRSCR. Or la procédure CLRSCR se trouve dans la librairie standard CRT. Opération de suppression Pour supprimer un mot au sein de la base de données, il suffit d’aller au menu « Dictionnaire », puis sur « Supprimer un mot clé ».
A son clic, voici la fenêtre qui s’affiche.
Le système nous invite à donner le mot en algorithme à supprimer et sa signification en langage Pascal.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
90
Nous avons installé le logiciel MSAlgoPascal® au niveau de la salle de travaux pratiques de l’I.F.P depuis le mois de mars dernier. Sous la direction de monsieur Moussa BA, professeur de Pascal, les cours du langage Pascal s’effectuent, depuis cette date, via ce logiciel comme support didactique. Pour chaque problème donné, les étudiants l’analysent, écrivent l’algorithme associé et l’implémentent directement au niveau du traducteur. Ce dernier contrôle la validité de l’algorithme, envoie des messages en cas d’erreur(s) et si l’algorithme est correct, MSAlgoPascal® traduit ce dernier en langage Pascal. A la fin de la traduction, les étudiants apprennent aisément le langage Pascal en le comparant avec l’algorithme. Des questionnaires étaient distribués à la fin de chaque mois pour évaluer le niveau de maîtrise des étudiants et aussi identifier les difficultés rencontrées lors des travaux pratiques. Les résultats obtenus étaient explicités à travers des questionnaires.
5.1 Période d’administration des questionnaires 5.1.1 Questionnaire du mois d’avril (pré-test) Ce questionnaire a été administré à 16 élèves juste avant que les cours de travaux pratiques ne s’effectuent via le logiciel MSAlgoPascal® Libellé des questions 1) 2) 3) 4)
Aimez-vous les algorithmes que vous faites en classe ? Savez-vous les avantages de ces algorithmes ? Que pensez-vous de ce langage de programmation (Pascal) ? (OUI = positif, NON = négatif) Quelles sont les difficultés majeures que vous rencontrez en manipulant Turbo Pascal ? (La réponse « OUI » signifie que des difficultés ont été énumérées) 5) Comprenez-vous facilement les messages d’erreurs qui sont affichés par le compilateur ? 6) Arrivez-vous à corriger vos propres erreurs ? 7) L’interface de Turbo Pascal vous parait-il facile à manipuler ?
Exploitation du questionnaire N° de la question 1 2 3 4 5 6 7
OUI 75% 62,5% 93,75% 31,25% 18,75% 25% 43,75%
POURCENTAGE NON PLUS OU MOINS 25% 0% 18,75% 18,75% 0% 6,25% 50% 18,75% 31,25% 50% 31,25% 43,75% 37,5% 18,75%
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
91
Le tableau statistique précédent entraîne l’histogramme ci-dessous.
Pourcentage
Sondage du mois d'avril 100% 90% 80% 70% 60% 50% 40% 30% 20% 10% 0%
OUI NON PLUS OU MOINS
1
2
3
4
5
6
7
Numéro question
D’après ces statistiques, nous remarquons que : 50% des étudiants éprouvent des difficultés à comprendre le langage Pascal. 37, 5% pensent que l’interface utilisateur de Turbo Pascal n’est pas conviviale. 31,25% n’arrivent pas du tout à comprendre les messages d’erreur envoyés par le compilateur. 43,75% éprouvent des difficultés pour comprendre ces messages d’erreur. Grâce à ce diagnostic, nous pouvons conclure qu’il y a un réel problème de compréhension et de maîtrise au niveau des étudiants. C’est ce qui nous a amené à installer le traducteur pour voir si réellement il y aura une évolution par rapport à la compréhension.
5.1.2 Questionnaire du mois de mai Ce questionnaire a été administré à 15 élèves après un mois de travaux pratiques avec le logiciel MSAlgoPascal®. Libellé des questions 1) Quelle est la chose qui vous a marqué en premier lieu sur le logiciel MSAlgoPascal® ? (La réponse « OUI » signifie qu’il y a un étonnement ou une surprise) 2) Avez-vous eu la possibilité d’écrire votre premier algorithme ? 3) Etes-vous satisfait de la traduction que vous propose MSAlgoPascal® ? 4) Arrivez-vous à corriger vos propres erreurs sans l’intervention d’une autre personne ? 5) Comprenez-vous les messages d’erreur que vous signale MSAlgoPascal® ? 6) Pour exécuter vos programmes via le compilateur Pascal, trouvez-vous utile de passer d’abord par le traducteur d’algorithme en langage Pascal ? 7) Le fait d’utiliser en même temps les 2 logiciels (Turbo Pascal et MSAlgoPascal®) pendant les cours de Pascal vous facilite-t-il davantage la compréhension ? 8) Trouvez-vous en MSAlgoPascal® un bon support d’enseignement ? Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
92
9) Depuis que vous avez découvert ce traducteur, avez-vous mieux compris la programmation en Pascal ?
Exploitation du questionnaire N° de la question OUI
POURCENTAGE PLUS OU NON MOINS 0% 0%
1
100%
2
60%
20%
20%
3
60%
20%
20%
4
33,3%
53,3%
13,4%
5
60%
20%
20%
6
53,3%
33,3%
13,4%
7
53,3%
33,3%
13,4%
8
80%
13,3%
13,4%
9
86,7%
13,3%
0%
Le tableau statistique précédent entraîne l’histogramme ci-dessous.
Sondage du mois de mai 120%
Pourcentage
100% 80%
OUI
60%
NON PLUS OU MOINS
40% 20% 0% 1
2
3
4
5
6
7
8
9
Numéro question
D’après les sondages, nous avons : 60 % des étudiants sont satisfaits de la traduction de l’algorithme en langage Pascal. 33,33 % des étudiants arrivent à corriger leurs propres erreurs sans l’intervention d’une tierce personne. 60 % des étudiants comprennent les messages d’erreur de MSAlgoPascal®. 53,3 % des étudiants éprouvent un besoin de passer d’abord par le traducteur avant d’exécuter leurs programmes en langage Pascal. 53,3 % des étudiants pensent que le fait d’utiliser les deux logiciels (MSAlgoPascal® et Turbo Pascal) leur facilite davantage la compréhension. 80 % des étudiants trouvent que MSAlgoPascal® est un bon support d’enseignement. Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
93
86,7 % des étudiants affirment avoir mieux compris la programmation en langage Pascal après la découverte de ce traducteur. L’analyse des données, nous permet de conclure qu’il y a une bonne évolution de la compréhension du langage Pascal par les étudiants. Donc le besoin pour les débutants en informatique ayant recours au traducteur devient de plus en plus réel.
5.1.3 Questionnaire du mois de juin Après quelques corrections sur les bogues du logiciel, nous avons administré le questionnaire suivant sur 17 étudiants. Libellé des questions 1) Depuis 4 mois vous utilisez avec le professeur de Pascal le traducteur MSAlgoPascal®. Pensez-vous qu’il vous a été utile dans les explications ? 2) Conseillerez-vous vos frères et sœurs qui viendront l’année prochaine d’utiliser MSAlgoPascal® avec le professeur ? 3) Le logiciel MSAlgoPascal® est-il un bon outil pédagogique pour l’apprentissage du langage Pascal ? 4) Aujourd’hui vous devez être en mesure d’écrire vos programmes sans passer par le traducteur. Ce fait est-il dû par MSAlgoPascal® ? 5) Depuis que vous avez fait la découverte de ce traducteur, avez-vous mieux compris la programmation en Pascal ? 6) Arrivez-vous aujourd’hui à corriger vos propres erreurs sans l’intervention du professeur ? 7) Comprenez-vous les messages d’erreurs que vous signale MSAlgoPascal® ? 8) Arrivez-vous à tirer profit de ces messages ? 9) Le fait d’utiliser en même temps les 2 logiciels pendant les cours de Pascal vous facilite-t-il davantage la compréhension ? 10) Souhaitez-vous que l’on utilise pendant les cours de Pascal : MSAlgoPascal® uniquement Turbo Pascal uniquement les 2 logiciels à la fois (OUI = MSAlgoPascal uniquement, NON = Turbo Pascal uniquement, Plus ou moins = les deux à la fois) 11) Souhaitez-vous que le professeur de Pascal vous explique d’abord en algorithme puis en Pascal ou directement en Pascal sans passez par l’algorithme ?
Exploitation du questionnaire N° de la question 1 2 3 4 5 6 7 8 9 10 11
OUI 88,2% 82,3% 82,3% 53% 70,6% 64,7% 70,6% 58,8% 82,4% 88,2% 88,2%
POURCENTAGE NON PLUS OU MOINS 11,8% 0% 17,7% 0% 17,7% 0% 35,2% 11,8% 23,5% 5,9% 29,4% 5,9% 23,5% 5,9% 0% 41,2% 11,8% 5,8% 17,6% 29,4% 11,8% 0%
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
94
Ce tableau statistique donne l’histogramme ci-dessous :
Sondage du mois de juin 100,00% 90,00%
Pourcentage
80,00%
OUI
70,00%
NON
60,00%
PLUS OU MOINS
50,00% 40,00% 30,00% 20,00% 10,00% 0,00% 1
2
3
4
5
6
7
8
9
10
11
Numéro question
Ce sondage nous informe que : 88,2 % des étudiants pensent que MSAlgoPascal® a été utile pour l’apprentissage du langage Pascal. 82,3 % des étudiants conseilleront leurs frères (les générations à venir) d’utiliser ce traducteur pour apprendre rapidement le langage Pascal. 82,3 % des étudiants pensent que le logiciel est un bon outil pédagogique. 53 % des étudiants pensent qu’ils sont arrivés aujourd’hui à écrire leurs premiers programmes Pascal à cause de MSAlgoPascal®. 64,7 % des étudiants arrivent à corriger leurs propres erreurs sans l’intervention de qui que ce soit. 82,4 % des étudiants disent que le fait d’utiliser les 2 logiciels pendant les cours de Pascal leur facilite davantage la compréhension. 88,2 % des étudiants veulent que le professeur de Pascal leur explique d’abord en algorithme puis en langage Pascal et veulent aussi que ces 2 logiciels soient utilisés en classe. Qu’il nous soit permis de dire en somme que, d’après ces trois histogrammes précédemment vus, le logiciel MSAlgoPascal® a eu un impact sur la performance des apprentissages des étudiants cibles en langage Pascal.
5.2 Appréciations 5.2.1 Appréciation des étudiants La question « comment trouvez-vous finalement MSAlgoPascal® ? » nous a permis d’avoir une vue globale de MSAlgoPascal® sur l’idée que les étudiants se font du logiciel : Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
Appréciation Pourcentage Pourcentage
Médiocre
Passable
A bien
Bien
Très bien
Excellent
0%
mois de mai 26,66 % 26,66 %
20 %
20 %
6,66 %
0%
mois de juin 0% 25 %
25 %
31,25 %
18,75 %
95
Appréciation des étudiants 0,35 0,30
fréquence
0,25 0,20
Mois de mai
0,15
Mois de juin
0,10 0,05 0,00 Médiocre Passable
A bien
Bien
Très bien Excellent
mention
Cet histogramme montre clairement que le logiciel MSAlgoPascal® a été vivement apprécié ; ce qui prouve que les étudiants ont progressivement compris l’utilité de MSAlgoPascal® dans les travaux dirigés en langage Pascal.
5.2.2 Appréciation du professeur de Pascal « Comme l’indique son nom, « MSAlgoPascal® » est un logiciel qui permet de traduire un algorithme en langage Pascal. Il importe de préciser qu’ayant utilisé et testé MSAlgoPascal® dans le cadre de mes enseignements du langage Pascal avec les étudiants en Informatique de Gestion de l’I.F.P, je dois dire ce qui est important de préciser c’est la démarche très courageuse de son concepteur. La méthodologie utilisée est la démarche qui permet de conduire l’analyse d’un problème depuis la lecture de l’énoncé jusqu'à la formulation d’un algorithme. Sous le vocable MSAlgoPascal® se cache en fait deux activités. L’une consiste à faire l’analyse du problème à traiter afin d’élaborer un algorithme approprié. L’autre est la traduction de cet algorithme dans un langage de programmation « compréhensible » par l’ordinateur, qui pourra donc se charger de l’exécuter. C’est moins le caractère traducteur qui est mis en exergue que la démarche algorithmique qui consiste à l’utilisation des « briques » de base de la programmation structurée, comme les Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
96
variables, les instructions de contrôles par sélection et par répétition, les fonctions et procédures. Cette application traduit fidèlement l’algorithme en son équivalent en langage Pascal. Cependant, elle permet à l’utilisateur d’être rigoureux dans l’art de conduire l’analyse des problèmes en toute logique. Pour ceux-là qui pourraient penser que ce produit rend paresseux les étudiants, nous disons que l’utilisateur devra lors de la traduction d’affiner certaines instructions pour rendre conviviale le programme à exécuter. C’est là où l’utilisateur devra faire étalage de ses connaissances du langage Pascal. » Moussa BA, professeur de Pascal à l’I.F.P
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
D
97
ans ce mémoire, nous avons mené l’étude de la conception d’un générateur automatique de codes pour l’apprentissage du langage Pascal.
L’étude préalable nous a permis de recenser l’ensemble des difficultés rencontrées sur l’apprentissage de ce dernier au niveau des étudiants de l’I.F.P. En procédant étape par étape, nous avons pu modéliser l’existant, relever les difficultés et apporter des corrections nécessaires. A cet effet, nous nous sommes fixés des objectifs pour améliorer l’apprentissage du langage Pascal. C’est ce qui a donné naissance à un logiciel traducteur d’algorithme en langage Pascal nommé MSAlgoPascal®. Qu’il nous soit permis de dire que nous avons pleinement atteint nos objectifs car d’après les statistiques précédemment vus, le logiciel MSAlgoPascal® a permis aux étudiants cible de mieux comprendre la programmation en langage Pascal et qu’en définitive, nous pouvons dire que le cycle de vie d’un programme informatique pourrait aussi être exprimée de la manière suivante :
Problème
Analyse
Algorithme
+ Données
Résultat
Exécution
Générateur
Langage
de codes
évolué
Edition des liens
Compilation
Nous sommes aujourd’hui heureux de produire un tel logiciel qui contribuera quand même à la lutte contre la fracture numérique et qu’à l’avenir nous espérons en faire de même pour le langage C++. Pour améliorer la qualité de son enseignement, le corps administratif de l’Institut de Formation Professionnelle doit, dans les années à venir, mettre à la disposition de chaque étudiant ce logiciel.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
98
Bernard FARLA.- Turbo Pascal Facile sous Windows.- Marabout, Alleur (Belgique) 1992 J MORLEGHEM. – L’indispensable pour Turbo Pascal sur PC.- Marabout, Alleur (Belgique) 1990 Vincent GRANET.- Algorithme et programmation en Java.- Dunod, Paris, 2000 Thomas BINGZINGER.- Borland Delphi 6.- CampussPress, 2002 Kéba DIOP.- Algorithmique et structures de données.- Tome 1, Press de l’université de l’UNIS. Théophile NOUATIN.- Les bases de la programmation avec C++.- Itss Soft Institute, 1998. Microsoft Encarta 2004
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
99
Concepteur du langage Pascal
M
is au point entre 1967 et 1971 par Niklaus WIRTH, le langage Pascal est un langage structuré et compilé, dérivé du langage ALGOL. Destiné à traiter des données informatiques, il simplifie la syntaxe d’ALGOL tout en y ajoutant des types et des structures de données supplémentaires, tels que les types énumérés, les fichiers, les enregistrements et les ensembles. Bien que le Pascal soit un langage résolument procédural qui excelle dans la réalisation d’applications mathématiques, il existe également une version de Pascal orientée-objet, utilisée aussi dans le développement d’applications. Il est souvent enseigné aux étudiants en raison de sa programmation efficace et très structurée. Niklaus WIRTH.- Source encarta 2004
Exemple de traduction d’un algorithme en langage Pascal par MSAlgoPascal® Algorithme % MSAlgoPascal(R) (C) MBODJ.SYSTEM(R) (2003-2004) % ALGO Gestion_Repertoire_Telephonique Const Max = 100 Type Personne = Structure Nom : Chaîne [10] Prénom : Chaîne [15] Tel : Chaîne [12] FinStructure TabTéléphone = Tableau [1..Max] de Personne Variable Tab : TabTéléphone n : Entier Choix : Entier % Cette procédure affiche toutes les personnes se trouvant dans le tableau (vecteur) % Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
100
Procédure AfficherPersonne variable i : Entier Début Pour i=1 à n Faire Afficher "Nom : ", Tab[i].Nom," " Afficher "Prénom: ", Tab[i].Prénom, " " Afficher "Téléphone: ", Tab[i].Tel a_la_ligne FinPour FinProcédure % Cette procédure ajoute une personne dans le tableau % Procédure Ajout Début Si n = Max Alors Afficher "Pas d'espace mémoire !" Sinon n := n+1 Afficher "Nom =" ; Saisir (Tab[n].Nom) Afficher "Prénom ="; Saisir (Tab[n].Prénom) Afficher "Téléphone ="; Saisir (Tab[n].Tel) FinSi Attente FinProcédure % Cette procédure trie les personnes par ordre alphabétique % Procédure Tri Var i,j : Entier Tampon : Personne Début Pour i=1 à n-1 Faire Pour j= i+1 à n Faire Si (Tab[i].nom > Tab[j].nom) ou ((Tab[i].nom = Tab[j].nom) et (Tab[i].Prénom > Tab[j].Prénom)) Alors Tampon := Tab[i] Tab[i] = Tab[j] Tab[j] = Tampon FinSi FinPour FinPour FinProcédure DÉBUT n=0 Repeter EffacerEcran AfficherLigne "REPERTOIRE TELEPHONIQUE" AfficherLigne "1 : Ajout d'une personne" AfficherLigne "2 : Trier les personnes" AfficherLigne "3 : Afficher toutes les personnes" AfficherLigne "4 : Quitter" A_LA_LIGNE Afficher "Choix =" Saisir (Choix) Selon Choix de 1 : Ajout 2 : Tri 3 : AfficherPersonne Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
101
FinSelon JusQua Choix = 4 Attente FINALGO
Traduction en langage Pascal {MSAlgoPascal(R) (C) MBODJ.SYSTEM(R) (2003-2004)} PROGRAM Gestion_Repertoire_Telephonique; USES CRT; CONST Max = 100; TYPE Personne = RECORD Nom: STRING [10]; Prénom: STRING [15]; Tel : STRING [12]; END; TabTéléphone = ARRAY [1..Max] OF Personne; VAR Tab : TabTéléphone; n : INTEGER ; Choix : INTEGER ; {Cette procédure affiche toutes les personnes se trouvant dans le tableau (vecteur)} PROCÉDURE AfficherPersonne ; VAR i : INTEGER ; BEGIN FOR i:= 1 TO n DO BEGIN WRITE ('Nom : ', Tab[i].Nom,' '); WRITE ('Prénom : ', Tab[i].Prénom, ' '); WRITE ('Téléphone : ', Tab[i].Tel); WRITELN ; END ; END ; {Cette procédure ajoute une personne dans le tableau} PROCÉDURE Ajout ; BEGIN IF n = Max THEN BEGIN WRITE ('Pas d''espace mémoire !’); END ELSE BEGIN n := n+1 ; WRITE ('Nom ='); READLN (Tab[n].Nom) ; WRITE ('Prénom ='); READLN (Tab[n].Prénom) ; WRITE ('Téléphone ='); READLN (Tab[n].Tel) ; END ; READLN ; END ; Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
Mémoire de fin d’études en analyste programmeur
I.F.P Octobre 2004
{
Cette procédure trie les personnes par ordre alphabétique
102
}
PROCÉDURE Tri ; VAR i,j : INTEGER ; Tampon : Personne ; BEGIN FOR i:= 1 TO n-1 DO BEGIN FOR j:= i+1 TO n DO BEGIN IF (Tab[i].nom > Tab[j].nom) OR ((Tab[i].nom = Tab[j].nom) AND (Tab[i].Prénom > Tab[j].Prénom)) THEN BEGIN Tampon := Tab[i] ; Tab[i] := Tab[j] ; Tab[j] := Tampon ; END ; END ; END ; END ; BEGIN n:= 0 ; REPEAT CLRSCR; WRITELN ('REPERTOIRE TELEPHONIQUE'); WRITELN ('1 : Ajout d''une personne'); WRITELN ('2 : Trier les personnes'); WRITELN ('3 : Afficher toutes les personnes'); WRITELN ('4 : Quitter' ); WRITELN; WRITE ('Choix ='); READLN (Choix) ; CASE Choix OF 1 : Ajout ; 2 : Tri ; 3 : AfficherPersonne ; END ; UNTIL Choix = 4 ; READLN ; END.
Générateur de codes : Traducteur automatique d’algorithme en langage Pascal MSAlgoPascal® © MBODJ.SYSTEM® Adama MBODJI
