Introduction au langage Ada cours pdf


Télécharger Introduction au langage Ada cours pdf

★★★★★★★★★★3.5 étoiles sur 5 basé sur 1 votes.
Votez ce document:

Télécharger aussi :


1.1     DEFINITIONS GENERALES

Le terme informatique (computer science) est un mot français désignant la science qui traite des données pour obtenir des résultats. Ce traitement est traditionnellement effectué à l'aide d'algorithmes. Un algorithme (algorithm) est une suite d'opérations à pour résoudre un problème (exemples 1.1 et 1.2).

Exemple 1.1 Algorithme de résolution de l'équation ax+b = 0.

1   sia et b sont chaque nombre réel est solution et l'algorithme est terminé; 1 si a est nul et b non nul, l'équation est insoluble et l'algorithme est terminé;

2   si a est non nul, soustraire b à gauche et à droite du signe = et l'on obtient ax = -b;

3   diviser chaque membre par a et l'on obtient le résultat cherché qui est x = -b/a.

L'algorithmique est une fondamentale de l'informatique qui traite de la conception, de la réalisation et de la vérification des algorithmes. Sa pratique est rendue difficile par la rigueur qu'il est nécessaire d'appliquer, rigueur souvent négligée par les néophytes, voire parfois par les concepteurs plus expérimentés.

Exemple 1.2 de mise en marche d'une voiture.

1   mettre la clé dans le démarreur;

2   serrer le frein à main;

3   mettre le levier des vitesses au point mort;

4   répéter les opérations suivantes tant que le moteur ne tourne pas:

-  mettre la clé dans la position marche;

-  tourner la clé dans le sens des aiguilles d'une montre;

-  attendre quelques secondes;

-  si le moteur ne démarre pas, remettre la clé dans la position initiale; 5 enclencher la première vitesse; 6 desserrer le frein à main.

Lorsqu'un ordinateur doit exécuter un algorithme, celui-ci doit être exprimé dans un langage compréhensible par la machine. Ce langage appelé langage machine (machine code) est composé de suites de chiffres 0 et 1 appelés bits qui correspondent à des états distincts des circuits qui composent la machine. Or le programmeur ne peut pas exprimer des algorithmes complexes avec des 0 et des 1! Il va utiliser unlangage plus proche d'une langue naturelle appelé langage de programmation (programming language). Une fois cet algorithme codé dans un langage de programmation, le programme source (sourceprogram) ainsi créé sera:

DEFINITIONS GENERALES

-  soit traduit complètement en langage machine par le compilateur (compiler) pour permettre ensuite l'édition de liens;

-  soit directement interprété (interpreted), c'est-à-dire que chaque code source est exécutée directement sans traduction préalable de tout le programme; cette ligne peut être traduite ou non en un langage proche du langage machine avant exécution.

La compilation (compilation) est donc une étape supplémentaire mais a l'avantage de produire un programme en langage machine. Ce programme en langage machine peut exister aussi longtemps que nécessaire. Chaque fois que le programme doit être utilisé, il le sera directement, ce qui implique que la compilation n'est nécessaire qu'après chaque modification du programme source.

L'interprétation (interpretation) est plus directe que la compilation, mais la traduction de chaque ligne a lieu lors de toutes les utilisations du programme.

L'édition de liens (link) est la phase pendant laquelle les différentes parties composant un programme sont réunies de manière à former un programme exécutable. C'est au cours de cette opération que des composants préexistants, par exemple des éléments graphiques, sont placés dans cet exécutable. Ces composants sont souvent regroupés dans une (ou plusieurs) bibliothèque(s)(library).

L'exécution (execution) d'un programme par un ordinateur consiste à exécuter les instructions machine les unes à la suite des autres. Elle sera nettement plus rapide dans le cas d'un programme compilé que pour un programme interprété.

Le déverminage (debugging) est l'activité de récupération, diagnostic et correction des erreurs de conception (logique) du programme. En d'autres termes, durant cette activité on procède à lamise au point du programme.

De manière générale, la programmation (programming) est l'art d'écrire des programmes (programs) en langage de programmation et constitue une autre discipline fondamentale de l'informatique. Un environnement de programmation (programming environment) ou de développement représente l'ensemble des outils logiciels (et parfois matériels) nécessaires à la conception, à la réalisation et à la maintenance d'applications complexes.

Il faut enfin définir le terme implémentation (implementation) qui regroupe toutes les caractéristiques (d'un langage de programmation) propres à un environnement de programmation particulier. Parfois ce terme représente l'environnement lui-même.

LANGAGES DE PROGRAMMATION

1.2     LANGAGES DE PROGRAMMATION

1.2.1       Historique

Plusieurs centaines de langages de programmation ont été proposés au cours de l'évolution de l'informatique. La majorité d'entre eux s'appliquaient à des domaines très particuliers alors que d'autres se voulaient plus généraux. Leur succès ou leur échec tient autant à leurs qualités ou leurs défauts qu'à la période où ils apparurent sur le marché ou dans les universités. Le tableau 1.1 décrit par ordre chronologique d'apparition plusieurs langages de programmation parmi les principaux utilisés jusqu'à aujourd'hui ainsi que leur principal domaine d'application. Même s'ils ne sont pas cités explicitement, il faut également mentionner les langages d'assemblage appelés assembleurs (assemblers), utilisés surtout pour programmer au niveau de la machine. Finalement, il faut préciser qu'il existe encore d'autres catégories de langages informatiques destinés par exemple à la simulation de systèmes ou à la conception de circuits électroniques.

Tableau 1.1 Principaux langages de programmation.

Année

Langage

Domaine d'application

Remarques

1955

Fortran

Calcul                 scientifique

Langage ancien, dont les versions plus récentes comportent encore des bizarreries héritées des années 50; normalisé actuellement sous l'appellation

Fortran 98.

1960

Algol-60

Algorithmique

Premier langage dit structuré grâce à la notion de blocs.

1959

Lisp

Intelligence artificielle

Premier langage non impératif.

1961

Cobol

Applications commerciales

Langage verbeux, peu maniable, encore très utilisé en informatique de gestion.

1964

PL/1

Langage général

Complexe, ayant la prétention d'être universel et regroupant les spécificités de Cobol et Fortran, créé et utilisé chez IBM.

1965

Basic

«Travail à la maison»

Basique, simple d'utilisation mais peu adapté à la programmation structurée.

1970

Prolog

Intelligence artificielle

Langage non impératif.

1971

Pascal

Enseignement

Créé à l'Ecole polytechnique de Zurich, diffusé partout mais souffrant des différences présentes dans les nombreuses versions existantes.

LANGAGES DE PROGRAMMATION

Tableau 1.1  (suite) Principaux langages de programmation.

Année

Langage

Domaine d'application

Remarques

1972

C

Programmation système

Accès facile au largement diffusé; normalisé sous l'appellation ANSI-C.

1976

Smalltalk

Langage général

Programmation orientée objets, prototypage rapide.

1980

Modula-2

Programmation système

Descendant de Pascal, mêmes problèmes de versions différentes.

1983

Ada

Langage général

Riche, utilisé pour développer des systèmes complexes et fiables, ainsi que pour des applications temps réel critiques; normalisé sous l'appellation Ada 83.

1984

C++

Langage général

Successeur de C; permet la programmation orientée objets; normalisé par l'ISO en 1998.

1995

Ada 95

Langage général

Successeur d'Ada 83; ajoute la programmation orientée objets, par extension, etc; normalisé sous l'appellation Ada 95.

1996

Java

Internet

Semblable à C++, mais plus sûr; permet la programmation d'applications classiques mais aussi d'applets.

1.2.2       Langage de programmation Ada

L'expérience montre que le premier langage de programmation appris est fondamental pour l'avenir d'un programmeur. En effet, les habitudes prises sont ancrées si profondément qu'il est très difficile de les modifier voire de s'en défaire! L'apprentissage de la programmation doit donc s'effectuer avec un langage forçant le programmeur à adopter de bonnes habitudes (sect. 1.3). Il est toujours plus facile d'évoluer vers de nouveaux langages lorsque ces bonnes habitudes sont acquises. Le langage Ada aide à l'apprentissage d'une bonne programmation en obligeant le programmeur à se soumettre à certaines contraintes et en lui fournissant une panoplie assez riche d'outils agréables à utiliser. Ces outils vont lui permettre de coder relativement simplement un algorithme même complexe et de refléter fidèlement sa structure. La version d'Ada présentée dans cet ouvrage est celle définie en 1995 [ARM] et normalisée ISO.

BONNES HABITUDES DE PROGRAMMATION

1.3     BONNES HABITUDES DE PROGRAMMATION

Le but de tout programmeur est d'écrire des programmes justessimpleslisiblesfiables et efficaces. Pour la justesse, la simplicité et la lisibilité, les quelques points suivants sont fondamentaux (la liste est non exhaustive!):

-  Réfléchir et imaginer de bons algorithmes de résolution avant d'écrire la première ligne du programme.



-  Une fois l'algorithme général trouvé, en écrire l'esquisse dans un formalisme pseudo-formel, puis préciser cette esquisse pour finalement coder l'algorithme dans le langage de programmation choisi.

-  du codage, choisir des noms parlants (utiliser des mnémoniques) pour représenter les objets manipulés dans le programme, commenter chaque morceau du programme de manière explicative plutôt que descriptive et tester chaque module, procédure, fonction soigneusement.

Pendant toute la démarche, adopter et appliquer systématiquement des conventions simples et cohérentes.

DE L'ANALYSE DU PROBLEME - L'EXECUTION DU PROGRAMME

1.4     DE L'ANALYSE DU PROBLEME - L'EXECUTION DU

Voici une ébauche de marche à suivre pour la création de programmes à partir d'un problème donné:

1   bien lire l'énoncé du problème, être certain de bien le comprendre;

2   réfléchir au problème, déterminer les points principaux à traiter;

3   trouver un bon algorithme de résolution (sect. 1.7), l'écrire dans le formalisme choisi;

4   coder l'algorithme en un programme écrit sur papier (au moins pour son architecture principale);

5   introduire le programme dans l'ordinateur au moyen d'un éditeur de texte;

6   compiler le programme;

7   effectuer l'édition de liens du programme;

8   le programme, vérifier son bon fonctionnement par des tests significatifs.

En cas d'erreurs de compilation, les corriger avec l'éditeur de texte puis recommencer le point 6. Si le programme fonctionne mais donne des résultats faux, ou si l'exécution du programme se termine par un message d'erreur, cela signifie qu'il y a des fautes de logique. Il faut réfléchir, parfois longuement, trouver l'origine des fautes en particulier en s'aidant des outils de déverminage, modifier le pro-gramme en conséquence puis reprendre au point 6.

Lorsque les programmes source dépassent une page, il serait judicieux de s'habituer à les concevoir et les tester parétapes. Cette façon de faire devient en effet indispensable lorsque la taille du code écrit dépasse, par exemple, deux cents lignes, ce qui représente encore un tout petit programme!

PROPRIETES D'UN PROGRAMME

1.5     PROPRIETES D'UN PROGRAMME

Lors de l'écriture application, les propriétés énumérées ci-après devraient toujours guider le programmeur lors des choix qu'il devra inévitablement effectuer, que le programme soit simple ou compliqué. En effet, un code bien écrit sera toujours plus fiable, lisible, simple, juste et même efficace.

Ces propriétés sont les suivantes:

-  La fiabilité (reliability) à ce que les erreurs de programmation soient détectées à la compilation ou à l'exécution afin que le programme n'ait jamais de comportement imprévu. Il est naturellement préférable que le plus d'erreurs possible soient signalées à la compilation de manière à diminuer la phase de test du programme, toujours très coûteuse en temps et en argent, ainsi que le code supplémentaire généré pour la vérification de contraintes liées à l'exécution de certaines instructions. Un langage fortement typé répond à ce critère de fiabilité.

-  La lisibilité (readability) permet la documentation associée au programme, de simplifier la correction des erreurs et de faciliter les modifications futures. Un langage permettant la construction de structures de données et disposant de structures de contrôle répond à ce critère. Rappelons cependant que les habitudes du programmeur sont au moins aussi importantes que le langage!

-  La simplicité (simplicity) est un critère évident: ne jamais compliquer lorsqu'il est possible de rester simple.

-  L'efficacité (efficiency) doit naturellement être suffisante afin que le programme s'exécute rapidement, mais ne doit pas constituer l'idole à laquelle tout le reste est sacrifié. Une conception bien pensée, une bonne structuration du code sont beaucoup plus importantes que l'accumulation d'astuces subtiles permettant un gain de temps minime lors de l'exécution du programme.

-  Enfin, on appelle portabilité (portability) la propriété représentant l'indépendance d'une application ou d'un langage de programmation par rapport à la machine utilisée. Cette propriété joue un rôle fondamental lors de l'évolution des programmes au cours du temps. Plus un logiciel est portable, moins il sera sensible aux changements de matériels utilisés.

EXEMPLE INTRODUCTIF

1.6     EXEMPLE INTRODUCTIF

Une bonne introduction à l'algorithmique consiste à étudier un problème simple (exemple 1.3) dont la résolution sera effectuée en respectant la marche suivre (sect. 1.4), restreinte aux points 1 à 4. Pour trouver un algorithme de résolution, il faut appliquer une méthode et l'utiliser chaque fois qu'un problème de programmation doit être résolu.

La méthode proposée ici est connue sous le nom de méthode de décomposition par raffinements successifs. Cet exemple va également permettre d'insister sur les bonnes habitudes de programmation et d'introduire les premières notions de programmation en langage Ada.

Exemple 1.3 Problème simple.

Dessiner dans une fenêtre graphique une figure composée de deux formes géométriques, soit un carré et un triangle isocèle. De plus, le programme doit annoncer le début et la fin du dessin dans une fenêtre de texte.

Du fait de sa compréhension de ce problème est immédiate, après avoir précisé que la disposition des formes est libre. Le point 1 de la marche à suivre est fait. 

METHODE DE DECOMPOSITION PAR RAFFINEMENTS SUCCESSIFS

1.7     METHODE DE DECOMPOSITION PAR RAFFINEMENTS SUCCESSIFS

Cette méthode est basée sur l'idée que, étant donné un problème à résoudre, il faut le décomposer en sous-problèmes de telle manière que:

-  chaque sous-problème constitue une partie du problème donné;

chaque sous-problème soit plus simple (à résoudre) que le problème donné;

-  la réunion de tous les sous-problèmes soit équivalente au problème donné.

Il faut ensuite reprendre chaque sous-problème et le décomposer comme cidessus et recommencer jusqu'à ce que chaque sous-problème soit facile à résoudre. Une étape de cette suite de décompositions est appelée raffinement.

Une telle méthode est efficace après avoir été utilisée plusieurs fois. Lorsque les problèmes deviennent suffisamment complexes pour que la découverte d'une solu-tion ne soit plus un processus trivial, il est indispensable de l'appliquer systéma-tiquement. Elle donne en général de bons algorithmes résolvant les problèmes posés. Mais, comme toute méthode, elle a cependant ses limites. Celleci devient inutilisable lorsque la complexité des problèmes est tout simplement trop grande pour que la suite de raffinements soit facilement exploitable.

1.8     APPLICATION - L'EXEMPLE INTRODUCTIF

1.8.1       Considérations techniques

Selon le point 2 de la marche à suivre (sect. 1.4), il faut déterminer les points principaux à traiter. Le problème étant en partie géométrique, il faut tout d'abord savoir comment dessiner dans une fenêtre de l'écran d'un ordinateur. La documentation technique nous apprend que:

-  le système de coordonnées cartésiennes a son origine au point (0, 0) situé en haut à gauche de la fenêtre graphique;

-  les axes sont disposés comme le montre la figure 1.1.

Figure 1.1 Axes et coordonnées cartésiennes dans une fenêtre graphique.

Ceci étant établi, il faut connaître comment faire apparaître la fenêtre, dessiner un carré et un triangle, ou au moins des segments de droite. De même, il sera nécessaire de savoir comment écrire dans la fenêtre de texte. Ces renseignements constituent le point 2 de la marche à suivre.

1.8.2       Algorithme de résolution

L'algorithme de résolution (point 3, sect. 1.4) va être déterminé en utilisant la méthode décrite dans la section 1.7. Etant donné le problème initial, on en extrait les sous-problèmes:

1   annoncer le début du dessin;

2   ouvrir, faire apparaître la fenêtre de dessin;

3   dessiner le carré; 4 dessiner le triangle isocèle; 5 annoncer la fin du dessin.

Ceci constitue le premier raffinement. Comme les points 1, 2 et 5 sont immédiatement traduisibles en Ada, ils seront laissés tels quels. Le raffinement suivant est alors:

1   le début du dessin;

2   ouvrir, faire apparaître la fenêtre de dessin;

3   choisir la position du carré, i.e. celle du sommet en haut à gauche;

4   dessiner le carré avec les côtés parallèles aux axes de coordonnées;

5   choisir la position du triangle isocèle, i.e. celle du sommet gauche; 6 dessiner le triangle isocèle sur la pointe, avec la base parallèle à l'axe des x. 7 annoncer la fin du dessin.

Afin de présenter un troisième raffinement, l'environnement Ada à disposition est supposé ne pas permettre le dessin d'un carré ou d'un triangle. La décomposition devient:

1   annoncer le début du dessin;

2   ouvrir, faire apparaître la fenêtre de dessin;

choisir la position du carré, i.e. celle du sommet en haut à gauche;

4   dessiner le côté supérieur depuis cette position;

5   dessiner le côté droit depuis l'extrémité droite du côté supérieur;

6   dessiner le côté inférieur depuis l'extrémité inférieure du côté droit;

7   dessiner le côté gauche depuis l'extrémité gauche du côté inférieur;

8   choisir la position du triangle isocèle, i.e. celle du sommet gauche;

9   dessiner la base depuis cette position;

10dessiner le côté droit depuis l'extrémité droite de la base; 11 dessiner le côté gauche depuis l'extrémité inférieure du côté droit; 12annoncer la fin du dessin.

Cette suite de raffinements s'arrête ici. En effet, même si la norme ne définit aucune opération graphique, des outils supplémentaires présents dans (presque) tous les environnements Ada permettent de dessiner un segment depuis un point courant et d'afficher un mot. La suite d'opérations 1, 2,  3.1, 3.2.1, etc., constitue un algorithme de résolution du problème donné.

1.8.3       Codage de l'algorithme en Ada

Un premier essai de codage de l'algorithme (point 4, sect. 1.4) donne le programme Exemple_Essai_1 (exemple 1.4). Il est correct, simple, fonctionne parfaitement mais est assezmalécrit. En effet, l'art de la programmation doit obéir à des conventions de style telles que celles décrites dans [AUS 95].

En particulier, il faut savoir que:

-  un programme doit être lisible, ce qu'il n'est pas;

-  un programme doit être commenté, ce qu'il n'est pas;

-  le doit refléter les décisionsprises par le programmeur, ici la grandeur et les points initiaux des dessins;

-  les nombres entiers peuvent signifier n'importe quoi! Il faut préciser leur signification en leur substituant des nomsparlants.

Exemple 1.4 Premier codage (maladroit) de l'algorithme obtenu.

with Ada.Text_IO; use Ada.Text_IO; with Spider; >use Spider; procedure Exemple_Essai_1 is begin

Put_Line ( "Debut 

Init_Window ("Fenetre de dessin");

Move_To (30, 120);

Line (50, 0);

Line (0, 50);



Line (- 50, 0);

Line (0, - 50);

Move_To (110, 120);

Line (80, 0);

(- 40, 40);

Line (- 40, - 40);

Put_Line ( "Fin du dessin"); end;

Malgré son apparente complexité, l'exemple 1.5 ci-après présente un programme source bien écrit et illustrant les points énumérés précédemment. Les qualités de style de ce programme résident en particulier dans:

-  les indications sur l'auteur, le but du programme (ici réduit au minimum), la date de création, les modifications éventuelles; d'autres informations générales pourraient bien entendu compléter cette introduction;

-  la mention systématique de noms représentant des nombres;

-  les explications décrivant chaque partie du programme; - la cohérence dans le choix des identificateurs;

-  la mise en page et l'alignement des lignes.

Il est vrai qu'en pratique, la production de logiciels dans des délais souvent extrêmement réduits conduit parfois à négliger l'effort de présentation du code. D'un autre côté, certaines entreprises imposent des normes strictes à respecter à la lettre. C'est le cas des industries pour lesquelles la qualité et la fiabilité du code produit est impérative comme dans le domaine spatial ou l'avionique par exemple.

Exemple 1.5 Codage corrigé de l'algorithme obtenu.

-- Auteur: Dupont Jean

-- But du programme: illustrer un codage soigne

-- Date de creation: 1 octobre 1999 -- Date de modification:

-- Raison de la modification:

-- Pour afficher dans la fenetre de texte with Ada.Text_IO; use Ada.Text_IO;

-- Pour lire les nombres entiers donnes par l'utilisateur with Ada.Integer_Text_IO; use Ada.Integer_Text_IO;

-- Pour travailler avec la fenetre de dessin with Spider; use Spider;

-- Ce programme illustre un codage soigne en Ada; il dessine un

-- carre et un triangle procedure Exemple_Bien_Fait is

Droite : constant := 1;

-- Pour se deplacer d'une unite

Gauche : constant := -1;

Haut   : constant := -1;

Bas    : constant := 1;

-- dans les quatre directions

-- Pour un trait vertical, le deplacement horizontal est nul A_L_Horizontale : constant := 0;

-- Pour un trait horizontal, le deplacement vertical est nul

A_La_Verticale : constant := 0;

Cote_Carre : constant := 50; -- Longueur d'un cote du carre

                Abscisse_Carre : Integer;    -- Abscisse et ordonnee du point

Ordonnee_Carre : Integer;    -- initial de dessin du carre

Demi_Base : ng>constant := 40; -- Longueur de la demi-base du

-- triangle

Abscisse_Triangle : integer; -- Abscisse et ordonnee du point

Ordonnee_Triangle : integer; -- initial de dessin du triangle begin -- Exemple_Bien_Fait

-- Presentation du programme a l'utilisateur

Put ("Bonjour. Je vais dessiner un carre et un triangle ");

Put_Line ("dans une fenetre de dessin.");

Put_Line ("Debut du dessin...");

-- Pour pouvoir dessiner dans la fenetre de dessin

Init_Window ("Fenetre

-- L'utilisateur donne le point initial de dessin du carre

Put ("Donnez l'abscisse du point initial du carre: "); Get (Abscisse_Carre);

Put ("Donnez l'ordonnee du point initial du carre: ");

Get (Ordonnee_Carre);

-- Dessin

Move_To (Abscisse_carre, Ordonnee_Carre);

Line (Cote_Carre * Droite, A_L_Horizontale); Line (A_La_Verticale, Cote_Carre * Bas);

Line (Cote_Carre * Gauche, A_L_Horizontale);

Line (A_La_Verticale, Cote_Carre * Haut);

-- L'utilisateur donne le point initial de dessin du triangle

Put ("Donnez l'abscisse initial du triangle:"); Get (Abscisse_Triangle);

Put ("Donnez l'ordonnee du point initial du triangle:");

Get (Ordonnee_Triangle);

-- Dessin du triangle.

Move_To (Abscisse_Triangle, Ordonnee_Triangle);

Line (2 * Demi_Base * Droite, A_L_Horizontale);

Line (Demi_Base * Gauche, Demi_Base * Bas);

Line (Demi_Base * Gauche, Demi_Base * Haut);

-- Message de fin du dessin et du programme

Put_Line ("Fin du dessin.");

Put_Line ("Fin du programme."); end Exemple_Bien_Fait;

STRUCTURE D'UN PROGRAMME ADA

1.9     STRUCTURE D'UN PROGRAMME ADA

Un programme Ada est composé de quatre parties principales:

-  La clause de contexte (context clause) qui sera développée par la suite (§ 10.5.1). Cette clause doit contenir les outils Ada que le programmeur peut utiliser sans avoir à les construire lui-même, et indispensables au fonctionnement du programme. Ces outils sont regroupés en paquetages, notion présentée ultérieurement (chap. 11). Il est nécessaire de les indiquer pour que le compilateur puisse en tenir compte lors de la phase de vérification et de traduction en code machine. La mention de ces paquetages se fera de manière intuitive en suivant les exemples fournis. Pour le programme Exemple_Bien_Fait la clause de contexte est la suivante:

with Ada.Text_IO; use Ada.Text_IO; with Ada.Integer_Text_IO; use Ada.Integer_Text_IO; with Spider; use Spider;

-  L'en-tête du programme, où est le nom du programme. Pour le programme Exemple_Bien_Fait l'en-tête est la suivante:

procedure Exemple_Bien_Fait is

-  La partie déclarative (declarative part), comprise entre l'en-tête et le mot reservé begin, contenant les déclarations (declarations) des objets (constantes, etc.) utilisés dans le programme. Ces objets représenteront des données traitées par le programme. La partie déclarative peut encore contenir d'autres déclarations comme des sous-programmes (chap. 4) ou encore des types (chap. 5).

-  Pour le programme Exemple_Bien_Fait la partie déclarative est la suivante:

Droite : constant := 1; Gauche : constant := -1;

Haut   : constant := -1;

Bas    : constant := 1;

A_L_Horizontale : constant := 0;

A_La_Verticale  : constant := 0;

Cote_Carre     : constant := 50;

Abscisse_Carre : Integer;

Ordonnee_Carre : Integer;

Demi_Base         : constant := 40;

Abscisse_Triangle : Integer;

Ordonnee_Triangle : Integer;

Il faut noter que les déclarations sont groupées logiquement: d'abord les objets généraux pour le dessin, puis ceux concernant le carré, finalement ceux concernant le triangle.

STRUCTURE D'UN PROGRAMME ADA

- La partie instructions du programme, comprise entre les mots begin et end, appelée souvent corps (body). Elle contient les instructions (statements) du programme, c'est-à-dire les actions à entreprendre sur les données. Parmi celles-ci et à titre d'exemple:

Put_Line ("Debut du dessin...");

Line (Cote_Carre * Droite, A_L_Horizontale);

C'est dans cette partie que se trouve, sous forme codée, l'algorithme choisi pour résoudre le problème. Il faut encore relever le rappel du nom du programme après le end final.

Finalement, il faut insister sur le fait qu'un programme doit être documenté, en particulier par des commentaires initiaux précisant le nom de l'auteur, la date de création, etc., comme suggéré dans l'exemple 1.5. Un guide méthodologique intitulé Style et qualité des programmes Ada 95 [AUS 95], destiné aux professionnels, fournit de nombreuses indications relatives aux différents aspects de l'écriture du code source (sect. 1.11).

1.10 CONSTITUANTS D'UN PROGRAMME

1.10.1     Généralités

Un programme est écrit un langage de programmation. Ce langage est composé de mots, symboles, commentaires, etc. Ceux-ci sont groupés en phrases dont compose le programme. Les phrases obéissent à des règles et ces règles déterminent de manière absolument stricte si une phrase est correcte ou non, c'est-à-dire si cette phrase respecte la syntaxe (syntax) du langage.

L'analogie avec les langues naturelles (français, allemand, etc.) est donc forte (fig. 1.2), la principale différence étant qu'une phrase française peut être formée de manière beaucoup moins rigoureuse et signifier néanmoins quelque chose. Or une phrase en Ada (ou tout autre langage de programmation) doit être absolument juste pour être comprise par le compilateur, sans quoi elle est obligatoirement rejetée!

Un programme Ada est composé de phrases appelées unités syntaxiques (syntactic units). Elles sont elles-mêmes constituées de mots, symboles, etc. appelés unités lexicales (lexical units). Chaque unité lexicale est une suite de caractères appartenant au jeu de caractères Ada.

Figure 1.2 Analogies avec la langue française.

1.10.2     Jeu de caractères en Ada

Le jeu de caractères en Ada comporte les caractères décrits dans [ARM 2.1]. Cet ensemble est normalisé ISO sous le nom LATIN-1 et comporte les lettres majuscules et minuscules, les lettres accentuées, les chiffres, les symboles de ponctuation, etc. Il comprend comme sous-ensemble tous les caractères du code ASCII (§ 3.8.1). On distingue les caractères imprimables (printable characters), lisibles, comme ceux cités ci-dessus, des caractères non imprimables  qui incluent les caractères de contrôle (control characters) interprétés de manière spéciale par l'implémentation (par exemple des caractères de contrôle comme le tabulateur horizontal (tab), le retour de chariot ( return), le saut de ligne (line feed), etc.).

1.10.3     Unités lexicales en Ada

Diverses unités lexicales existent en Ada:

-  Les identificateurs (identifiers), comme A, Limite_100, Cote_Carre, Put, etc. Un identificateur est un mot composé de lettres, de chiffres et du caractère _ et commençant obligatoirement par une lettre. S'il n'y a aucune limite théorique au nombre de caractères composant un identificateur, la norme Ada laisse à l'implémentation le soin de définir le nombre maximum de caractèressignificatifs, tout en précisant cependant que ce maximum doit être d'au moins deux cents caractères. Pour respecter les bonnes habitudes de programmation, les identificateurs doivent être parlants pour les lecteurs du programme! Les caractères significatifs servent à différencier deux identificateurs. Il faut relever que la casse (majuscule/ minuscule) n'est pas significative!

Le langage contient des identificateurs prédéfinis (predefined identifiers) comme Integer, Float, Text_IO, Constraint_Error, etc., que le programmeur peut éventuellement redéfinir dans son programme, mais dont le but principal reste néanmoins d'être utilisés tels quels, dans les situations pour lesquelles ils ont été créés. L'annexe [ARM A.1] en donne la liste.



-  Les mots réservés  (reserved words) qui sont des identificateurs restreints à un usage bien défini (toujours le même!), par exemple procedureisbegin, etc. La liste est fournie dans [ARM 2.9].

-  Les symboles (symbols) formés d'un unique caractère ou de deux caractères accolés, comme

< > = <= := + - , ;

la liste exhaustive se trouve dans [ARM 2.2].

-  Les commentaires (comments), c'est-à-dire n'importe caractères imprimables typographiés après le symbole -- et ce jusqu'à la fin de la ligne (fin de commentaire). Ils servent à expliquer le pourquoi et le comment des constructions auxquelles ils s'appliquent.

-  Les constantes numériques entières ou réelles ou plus simplement les nombres comme

123 -36 24E3 12.3 -234.0E3 -0.3E-2

les sections 2.2 et 2.3 définiront précisément ces constantes.

-  Les constantes caractères ou plus simplement les caractères, c'est-à-dire un seul caractère imprimable entre apostrophes comme

'a' '?' 'A' '='

la section 3.8 précisément ces constantes.

-  Les constantes chaînes de caractères ou plus simplement les caractères, c'est-à-dire une suite d'un ou de plusieurs caractères (éventuellement aucun) entre guillemets comme

"abcd" "CARRE" "triangle de Pascal" "=" la section 9.2 définira précisément ces constantes.

Il est parfois possible, voire pratique, d'accoler deux unités lexicales. Mais en règle générale, pour augmenter la lisibilité, deux unités lexicales seront séparées par au moins un espace, une tabulation ou une fin de ligne.

1.10.4     Unités syntaxiques et diagrammes syntaxiques

Les unités syntaxiques, comme les unités lexicales d'ailleurs, peuvent être décrites par des diagrammes appelés diagrammessyntaxiques. Un diagramme syntaxique</em> (syntactic diagram) permet donc de décrire l'orthographe d'une unité lexicale ou, comme son nom l'indique, la syntaxe (grammaire) d'une phrase du programme. Toute phrase est donc composée d'une séquence d'unités lexicales. Il est ainsi possible de vérifier si une instruction d'un programme en cours d'écriture est correcte en vérifiant sa syntaxe à l'aide des diagrammes syntaxiques du langage, Ada en l'occurrence.

Figure 1.3 Diagrammes syntaxiques définissant un identificateur et un chiffre.

Cette vérification est simple à réaliser; il suffit de parcourir le diagramme syntaxique dans le sens des flèches. Par exemple, la figure 1.3 montre un tel diagramme, permettant de vérifier qu'un «mot» est bien un identificateur. En suivant le diagramme syntaxique on rencontre une première bulle indiquant que le premier caractère d'un identificateur doit être une lettre. Si c'est le cas l'analyse peut continuer avec un choix: soit l'identificateur ne comporte qu'une lettre et le diagramme est quitté, soit il comporte d'autres caractères (lettres, chiffres ou _ ) et il faut alors suivre les autres chemins proposés par le diagramme et vérifier au fur et à mesure s'ils peuvent correspondre aux caractères constitutifs de la suite de l'identificateur. Si le diagramme est quitté, l'unité lexicale ou syntaxique analysée est correcte. Mais si l'on reste bloqué dans le diagramme sans possibilité d'en sortir, cela correspond à une erreur d'orthographe ou de syntaxe.

trois sortes de bulles dans les diagrammes syntaxiques: les cercles, les rectangles à «coins» arrondis et ceux à angle droit. Si les coins sont à angle droit, cela signifie un renvoi à une entité syntaxique différente. Il faut ainsi se reporter à un autre digramme, pour continuer l'analyse et en revenir en cas de succès, et ainsi de suite. Si les coins sont arrondis ou si c'est un cercle, alors le contenu représente un symbole ou un mot réservé qui devra être présent tel quel dans le texte analysé. Les bulles de la figure 1.3 contenant les mots lettre et chiffre renvoient donc à deux autres diagrammes syntaxiques dont l'un des deux est donné dans la même figure. Par contre, celles contenant les chiffres de 0 à 9, ou le caractère _ montrent que ces caractères doivent apparaître tels quels dans un nombre, ou un identificateur.

MISE EN PAGE D'UN PROGRAMME

1.11 MISE EN PAGE D'UN PROGRAMME

La page d'un programme Ada est assez libre. Cependant, et pour des raisons évidentes de clarté et de lisibilité d'un programme, il existe des conventions de style qu'il faut respecter, décrites dans [AUS 95]. En particulier il est demandé:

-  de commenter chaque déclaration ou instruction importante en indiquant la raison de sa présence; ce commentaire se place avant ou à côté de la déclaration ou instruction;

-  de choisir des identificateurs faciles à comprendre;

-  d'assurer un degré élevé de systématique et de cohérence;

-  d'effectuer une seule déclaration ou instruction par ligne;

-  d'indenter, c'est-à-dire vers la droite les déclarations ou instructions contenues dans une autre déclaration ou instruction. 

1.12 EXERCICES

1.12.1    Conception d'un algorithme

Ecrire un algorithme d'appel téléphonique à partir d'une cabine publique.

1.12.2    Déclarations et instructions

En Ada, peut-on déclarations et des instructions dans une partie déclarative? Dans un corps?

1.12.3    Utilisation d'un diagramme syntaxique

Utiliser le diagramme syntaxique de la figure 1.3 pour déterminer si les termes suivants sont des identificateurs en Ada:

Ada pRemiEr Découpe Ah__Ah Fin_ A+Tard Quoi? 

POINTS - RELEVER

1.13 POINTS - RELEVER

1.13.1     En général

Un algorithme est une suite d'opérations à effectuer pour résoudre un problème.

-  Saisie du programme, compilation, édition de liens, exécution, déverminage constituent les phases de création de tout programme.

-  Algol-60, Pascal, Modula-2, Ada, Ada 95 forment une famille de langages de programmation.

-  C, C++, Java forment une autre famille de langages de programmation.

-  Ada est utilisé dans cet ouvrage pour nommer la version 1995 du langage de programmation Ada normalisé la première fois en 1983.

-  Le respect des bonnes habitudes de programmation aboutit à des programmes plus simples et plus lisibles.

-  Fiabilité, lisibilité, simplicité, justesse et efficacité des programmes sont des propriétés parmi les plus importantes.

-  La méthode de décomposition par raffinements successifs aboutit à un algorithme de résolution du problème initial.

-  Les unités lexicales constituent les mots du texte du programme alors que les unités syntaxiques en forment les phrases.

-  Les diagrammes syntaxiques permettent de s'assurer que la syntaxe d'une construction est correcte.

-  Les identificateurs nomment les entités d'un programme et doivent toujours être parlants.

Les commentaires expliquent les raisons de la présence des constructions auxquelles ils s'appliquent.

1.13.2     En Ada

-  Un programme principal Ada est constitué dans l'ordre de la clause de contexte, l'en-tête, la partie déclarative et la partie instructions.

-  Les identificateurs sont composés d'une suite de lettres ou de chiffres, éventuellement séparés par le caractère _ et doivent obligatoirement commencer par une lettre.

C H A P I T R E  2

N O M B R E S

E T

E N T R E E S

- S O R T I E S

NOMBRES ET ENTREES-SORTIES DE BASE

RAPPELS

2.1     RAPPELS

Un programme Ada se compose de quatre parties:

-  la clause de contexte;

-  l'en-tête;

-  la partie déclarative; - la partie instructions.

La partie déclarative contient les déclarations des objets (constantes, variables, etc.) représentant les données que l'on veut traiter. Le corps contient les instructions du programme, c'est-à-dire les traitements à effectuer sur ces données. Le présent chapitre porte sur la représentation de ces données, en se limitant pour l'instant à deux catégories de nombres: les nombres entiers et réels.

2.2     TYPES ENTIERS

2.2.1     Motivation

Les nombres entiers sont traditionnellement utilisés les premiers dans un cours d'apprentissage de la programmation. En effet, ils ne posent pas (ou peu) de problèmes. Le travail avec eux est naturel puisqu'il correspond à de l'arithmétique. Un réflexe doit cependant être acquis le plus vite possible, il est mis en évidence dans la note 2.1.

NOTE 2.1 L'ensemble des nombres entiers n'est pas infini sur un ordinateur.

les nombres entiers ne sont évidemment pas utilisables sur un ordinateur; en effet, s'il existe en théorie une infinité de tels nombres, chacun d'entre eux occupe un ou quelques mots en mémoire et, de ce fait, l'ensemble des entiers représentables sur un ordinateur est fini. Généralement, les entiers sont représentés par 16 ou 32 bits, éventuel-lement 8 bits (§ 2.5.2). Les machines sur lesquelles ils occupent 64 bits ne sont encore pas très courantes.

2.2.2     Généralités

L'identificateur Integer est un identificateurprédéfini. Il signifie: «un objet (constante,  variable, etc.) de type Integer contiendra un nombre entier et rien d'autre». Les variables Abscisse_Carre, Ordonnee_Carre, etc., du programme Exemple_Bien_Fait (§ 1.8.3) sont de type Integer. Le type Integer fait partie des types discrets (discrete types, [ARM 3.2]). Il faut cependant déjà mentionner qu'il existe d'autres types qu'Integer pour les entiers (§ 2.2.7). Mais tous les nombres entiers (non explicitement basés) doivent respecter la syntaxe décrite par la figure 2.1.

Les constantes entières sont entiers eux-mêmes. Ces nombres peuvent être décimaux ou basés. Un nombre est un nombre écrit dans une base explicitement mentionnée, comprise entre 2 et 16. Le caractère _ est utile pour la lisibilité d'un nombre mais n'a aucune signification particulière.


207