Universit Ibn-Tofail Facult des Sciences de Knitra Dpartement dInformatique

Raliser par : Saad El Jaouhari & Zakaria Amchra

Sommaire

INTRODUCTION LES LOGICIELS NECESSAIRES STRUCTURE DU FICHIER DE CODE SYNTAXES GNRALES

Gnralits. Conditions. Boucles.

TYPES

Typage fort. Construction de nouveaux types. Attributs. Tableaux et chaines de caractres.

PROCDURES ET FONCTIONS EXEMPLE DE RCAPITULATION

Introduction
Ada est un langage de programmation conu par lquipe de CII-Honeywell Bull dirige par Jean Ichbiah en rponse un cahier des charges tabli par le dpartement de la Dfense des tats-Unis (DoD). Son dveloppement a commenc au dbut des annes 1980 pour donner Ada 83. Pour cela, l'quipe de Jean Ichbiah s'est inspire de son prcdent langage LIS (Langage d'Implmentation de Systmes).

Ada 83 a t ensuite repris et amlior au milieu des annes 1990 pour donner Ada 95, le premier langage objet normalis de manire internationale. Sous les auspices de lOrganisation internationale de normalisation (ISO), le langage a bnfici d'un amendement (Ada 2005) puis d'une nouvelle rvision appele Ada 2012.

Le nom Ada a t choisi en lhonneur dAda Lovelace, qui est suppose avoir t la premire femme informaticienne de lhistoire.

Les logiciels ncessaires

Nous allons au cours de ce chapitre, tlcharger et installer les logiciels ncessaires l'utilisation d'Ada. Eh bien non. Comme tout langage, Ada a besoin de deux types de logiciels: un diteur de texte avanc (appel IDE) et un compilateur. Nous utiliserons l'IDE appel GPS (mme si le logiciel Ada Gide pourra tre utilis) et ,le compilateur GNAT Tlchargement : Ada Gide : ici GPS : ici

Aprs linstallation du programme GPS nous allons expliquer un peu comment travailler avec le logiciel .

Comme le montre limage ci-dessous La fentre est dcoupe en quatre zones. La premire ne nous intresse pas pour l'instant. La seconde, juste en dessous affichera les fichiers et programmes de votre La troisime zone de la fentre est la zone principale, celle o vous rdigerez votre programme. Enfin, la quatrime zone est celle rserve au compilateur et la console.

Pour crer un nouveau projet : 1. Choisissez "Create new project with wizard " et cliquez sur OK. 2. Choisissez l'option "Single project" puis cliquez sur Forward. 3. Choisissez un nom pour votre projet et prcisez un rpertoire o l'enregistrer.

Note : crez un rpertoire spcifique par projet.

Structure du fichier de code

la structure du code de Ada est toujours spare en deux unit : Une spcification et un corps (la spcification pouvant tre omise dans de trs rare cas ). Sous GNAT , on spare ces deux parties dans deux parties dans deux fichiers distincts un (.ads) pour la spcification et un (.adb) pour le corps. Il y a deux type dunit de compilation : les paquetages et les sous-programmes. Un paquetage est une sorte de bibliothque , que contient plusieurs procdures (mais pas de main ) , alors quune procdure est une unit qui peut servir a crer un programme excutable . Voila la syntaxe de la spcification dun paquetage (.ads) : package Nom_Paquetage is -- code private -- code end Nom_Paquetage;

 Voila la syntaxe de limplmentation dun paquetage (.adb) : package body Nom_Paquetage is -- code end Nom_Paquetage; Vous remarquerez galement qu'un mot cl private spare en deux parties la spcification d'un paquetage. Il s'agit de la sparation entre les objets publics, c'est-dire accessibles par les fichiers utilisant ce paquetage, et les objets privs accessibles uniquement par le paquetage lui-mme . Ada diffrencie ces parties au niveau du paquetage IMPORTANT : Le nom du fichier doit imprativement tre le mme que celui de l'unit de compilation. On aurait donc ici respectivement Nom_Paquetage.ads et Nom_Paquetage.adb. Pour utiliser les entits dclares dans un paquetage. Il faut l'invoquer comme il suit : with Nom_Paquetage;

D'un certain point de vue, on peut galement considrer le paquetage comme un espace de nom (namespace) C++, c'est--dire que les units dcrites l'intrieur sont prfixer du nom de ce paquetage. En Ada, on utilise : use Nom_Paquetage; Parlons enfin des units de compilation procdures. Ce sont elles qui peuvent servir de point d'entre un programme (fonction main), mme si on peut les invoquer partir d'un autre programme via une directive with. Comme pour les paquetages, le nom du ficher qui contient la procdure principale doit tre le mme que celui de la procdure suivi d'un (.adb) . Lorsque l'unit de compilation est une procdure, il n'y a pas besoin de fichier de spcifications (mme si on peut en fournir un). Voici un exemple de procdure qui affiche" hello world " l'cran : with Ada.Text_Io; use Ada.Text_Io; procedure Principale is begin Put_Line ("Hello World"); end Principale;

Cette procdure utilise un paquetage prdfini. le paquetage Ada.Text_I0 , qui ralise les oprations d'entre /sortie sur texte directive dentre / sortie : Put(" chaine de caractre " ) : permet dafficher un texte. Put_Line ("chaine de caractre ") : permet dafficher un texte , avec un retour la ligne. Get(valeur) : permet de rcuprer une valeur entre a partir du clavier.

Exemple : procedure Principale is Variable : Integer := 0; --partie rserve aux dclarations begin Variable := Variable + 1; end Principale;

EXPLICATION DU CODE :
Pour les variable : on utilise son nom suivi de deux points et de son type , il est possible de dclarer plusieurs variables du mme type en sparant leurs noms par des virgules, cependant, s'il y a une valeur initiale, elle sera la mme pour toutes les variables de la dclaration en cours. Pour le commentaire : Les commentaires sont introduits par la chane et dfinissent le texte comme comment jusqu' la fin de la ligne.

Syntaxes Gnrales
I. Gnralits
Comme en C++. l'indication de fin d'instruction est le point virgule. Un bloc ne se dclare pas avec deux accolades, mais entre deux mots cls begin et end. Les variables ne peuvent tre dclares que dans une partie dclarative ,avant un begin. mais il est possible de crer un bloc l'intrieur d'un autre bloc. L'affectation est ralise via le symbole := qui n'est pas un oprateur (on ne pourra donc ni le redfinir, ni le mettre dans une condition, ni crire quelque chose du genre A := B := C). Il n'y a pas d'incrmentation raccourcie (++). Les principaux types primitifs sont Integer. Boolean Float et Character.

Prenons par exemple ce code qui ralise la dclaration d'un entier puis son incrmentation
procedure Principale is Variable : Integer := 0; begin Variable := Variable + 1; end Principale;

II. Conditions
Une condition en Ada s'nonce if condition then instructions elsif condition then instructions else instruction end if;. Il n'y a pas besoin d'entourer la condition de parenthses comme en C++. puisque le mot clef then (obligatoire!) marque la fin de la condition. Les oprateurs de comparaison sont les mme qu'en C++. l'exception de l'galit (== devient =) et de la diffrence ( != devient /=). Les oprateurs boolens sont not, and et or.

Voil un petit exemple de code qui teste si une valeur est plus grande que zro, et qui affiche un texte en consquence :
if Variable >0 then Put_Line (" > 0 "); else Put_Line (" <= 0 "); end if;

Il existe un autre schma de conditionnelles s'crivent avec case. En Ada, on utilisera case when. on ne peut en Ada faire de case que sur des entiers ou des types numratifs. Ada impose que tous les cas soient envisags. Si on ne sait pas ragir certaine valeurs, alors il faut mettre un choix par dfaut s'crit when others en Ada. Autre subtilit : lorsqu'un choix est valid, on ne cherche pas excuter les choix suivants, inutile donc de mettre d'instruction break. Dernire chose : Ada permet d'utiliser des plages de valeurs, ce qui permet de mettre un grand nombre de valeurs derrire un cas . Voici un exemple : case Variable is when 0 =>Put_Line (Zro); when 1 .. 9 => Put_Line (Chiffre positif); when 10 | 12 | 14 | 16 | 18 => Put_Line (Nombre pair entre 10 et 18); when others => Put_Line (Autre chose); end case;

en Ada, une boucle commence ncessairement pur le mot clef loop et se finit par le mot clef end loop. L'quivalent du break du C++ est l'instruction exit. Cette instruction peut galement faire l'objet d'une condition, avec la syntaxe exit when condition. Le loop qui ouvre la boucle est ventuellement prcd d'une instruction for ou while. L'instruction while est la plus simple , elle est suivie d'une condition, la condition n'a pas besoin dtre parenthse, Par exemple : while Variable < 10_000 loop Variable := Variable * 2; end loop;

Linstruction for s'agit dun parcoure incrmentale ou dcrmente entre deux borne discret . La syntaxe gnrale est : for variable in borne_inferieure borne_superieure loop. Les deux bornes doivent tre mises dans l'ordre croissant, mme si le parcours souhait va du maximum au minimum . Si ce n'est pas le cas, l'intervalle sera considr comme vide et le corps de la boucle ne sera pas excut. Pour faire un parcours l'envers, il faut ajouter le mot clef reverse aprs le mot clef in. Voil un exemple : for Variable in 0.. 9 loop Put_Line (IntegerImage (Variable)); end loop; for Variable in reverse 0 .. 9 loop Put_Line (IntegerImage (Variable)); end loop; IntegerImage : on va le voir aprs dans la partie attributs;

Types
I. Typage fort
L'une des plus notables caractristiques de Ada, et l'une des moins apprcies par les nouveaux programmeurs, c'est la quasi absence de conversions implicites, et la ncessit de convenir explicitement. Exemple :

procedure Bug is Variable_1 : Float := 10.0; Variable_2 : Integer := 1009; Resultat : Float; begin Resultat := Float (Variable_2) /Variable_1; end Bug;

II. Construction de nouveau types

Lorsque l'on prend l'habitude d'utiliser le typage fort. on se rend compte qu'il est souvent trs intressant de poser soi mme des contraintes de conversions afin d'viter des erreurs d'inattention. On peut par exemple vouloir interdire des affectations entre des variables contenant des minutes et des variables contenant des heures. Ada permet mme de dfinir des ensembles de dfinition, c'est--dire des bornes pour les types. Ainsi. On peut crire : procedure Test is type Heure is range 0 .. 23; type Minute is range 0 .. 59; H : Heure := 12; M : Minute := 56; begin M := H; H := 24; end Test;

La premire ligne de code qui suit le begin ne passera pas la compilation. Heure et Minute tant des types distincts, l'affectation de l'un dans l'autre est impossible sans conversion implicite. La ligne suivante sera accepte. se contentant de gnrer un message d'alerte. Mais a l'excution du code, une exception sera leve : il est en effet impossible d'affecter la valeur 24 a un type dont l'intervalle de dfinition va de 0 23. Ada propose une syntaxe pour la dclaration d'numration. En voici un exemple :

type Jour is (Lundi,Mardi,Mercredi,Jeudi,Vendredi,Samedi,Dimanche);

On peut galement dclarer un type comme tant drive d'un autre type. Le nouveau type peut alors are associe de nouvelles fonctions et a de nouvelles contraintes.

Voici un exemple d'utilisation du type jours :

type Jour_Ouvrable is new Jour range Lundi .. Vendredi; type Week_End is new Jour range Samedi .. Dimanche;

III. Attributs
Le langage dfinit un certain nombre de proprits pour chaque type : les bornes de debut et de fin pour les types numratifs et numriques. la faon de traduire une valeur de ce type en une chaine de caractres, et inversement. Toutes ces proprits sont appeles attributs du type. et sont accessibles en faisant suivre le nom du type d'une apostrophe.
Il existe un certain nombre d'attributs predfinis pour chaque type , les plus utilise sont : L'attribut Image et sa rciproque Value permet de transformer une valeur d'a peu prs n'importe quel type non composite en une chaine de caractres et inversement. Nous pouvons par exemple crire : declare A : Integer := 99; begin Put_Line (IntegerImage (A)); A = IntegerValue (98); end;

 Il existe aussi un certain nombre d'attributs qui ne sont valables que pour les types numratifs et entiers : il s'agit des attributs Val, Pos. Val renvoie la valeur d'un numratif en fonction de sa position. Pos renvoie sa position dans l'numration. Ainsi, pour avoir le code ascii d'un caractre, on peut crire : declare Carac : Character := a; Code_Ascii : Integer; begin Code_Ascii := CharacterPos (Carac); end; Les attributs First et Last n'ont pas de paramtres. ils renvoient respectivement la valeur du premier et du dernier lment du type enumeratif.

Les attributs Suce et Pred renvoient respectivement l'lment suivant et prcdent d'un type primitif.On peut par exemple obtenir le jour suivant de la manire qui suit :

Jour_Courant := JoursSucc (Jour_Courant); Pour connaitre plus dattributs : lien

IV. Tableau et chaine de caractres

A. Tableau
Un tableau en ada nest pas utilisable comme un pointeur vers une adresse mmoire quon connait au moins la taille . Un tableau est une structure a part entier qui possde un certaine nombre dattribut accessible , qui permettent entre autre daccder a ses borne . Exemple : declare Tableau : array (Integer range 1 .. 26) of Character; Carcou : Character := a; begin for I in TableauRange loop Tableau (I) := Carcou; Carcou := CharacterSucc (Carcou); end loop; end;

B.

Chaine de caractres

Une chaine de caractre n'est rien d'autre qu'un tableau de caractres Syntaxe : variable : string(born_inf..born_sup) ; Il est possible de rcuprer une chaine de caractre a partir du clavier en utilisant la commande get_line Syntaxe : variable := get_line;

IV. Procdure et fonction

en Ada, la notion de procdure est clairement spare de la notion de fonction. Outre le fait qu'une procdure ne peut pas renvoyer de valeur, une fonction n'a pas le droit d'avoir de paramtre rsultat . Il existe quatre types de modes de passages pour les paramtres en Ada : le mode in qui est le mode par dfaut quand rien n'est spcifi. le mode out qui modifie la valeur de la variable au niveau de l'appelant. le mode in out qui rcupre la valeur en entre et la modifie en sortie (l'quivalent de la rfrence non constante en C++), et le mode access qui demande un pointeur dont l'adresse ne sera pas modifie. Les fonctions ne peuvent avoir que des paramtres in ou access. alors qu'il n'y a aucune contrainte pour les paramtres d'une procdure. Voici tout de suite deux exemple de dclaration puis de dfinition de sous programmes :

procedure Proc (Var1 : Integer ; Var2 : out Integer; Var3 : in out Integer); function Func (Var : Integer) return Integer; procedure Proc (Var1 : Integer ; Var2 : out Integer ; Var3 : in out Integer) is begin Var2 := Func (Var1); Var3 := Var3 + 1; end Proc; function Func (Var : Integer) return Integer is begin return Var + 1; end Func;

Il n'est pas absolument ncessaire de dclarer le profil d'un sous programme avant de l'implmenter. mais il s'agit de l'usage le plus frquent. et les compilateurs qui incluent des options de style refusent en gnral une fonction non spcifie. Typiquement, la dclaration de la fonction est dans le .ads (sauf pour les fonctions trs spcifiques et trs internes) et les dfinitions sont dans un .adb. Comme en C++, une fonction non dclare ne peut pas tre utilise. Ada ne donne pas de dtails quant au mode de passage des paramtres. c'est--dire que l'on ne doit pas savoir s'ils le sont par valeur ou par rfrence.

Exemple de rcapitulation
Dans un fichier Arithmetique.ads : --contient les declaration des fonctions quon va utiliser dans le corp -du paquetage package Arithmetique is function Calculatrice return Positive; function Pgcd(A,B: Positive) return Positive; end Arithmetique;

Dans un fichier Arithmetique.adb : --corp du paquetage

with Text_Io; use Text_Io; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; Package body Arithmetique is function Calculatrice return Positive is Resultat : Positive ; N: Positive; Operateur : Character; begin Put_line("saisir un entier"); Get(Resultat); Put_line("saisir un operateur"); Get(Operateur);

while Operateur/='=' loop Put_line("saisir un entier"); Get(N); Put_line("saisir un operateur"); case Operateur is when '+' => Resultat:=Resultat+N; when '*' => Resultat:=Resultat*N; when others => null; end case; Get(Operateur); end loop; return Resultat; end Calculatrice;

function Pgcd(A,B : Positive) return Positive is Pa : Positive := A; Pb : Positive := B; begin while Pa/=Pb loop if Pa>Pb then Pa:=Pa-Pb; else Pb:=Pb-Pa; end if; end loop; return Pa; end Pgcd; end Arithmetique;

Dans un fichier main.adb : -- procedure principale le main nest pas un mot cle on peut le -remplacer par nimport quelle mot with Arithmetique; use Arithmetique; with Ada.Integer_Text_Io; use Ada.Integer_Text_Io; with Text_Io; use Text_Io; procedure Main is N, M: Positive; begin N:=Calculatrice; Put(N); New_Line; Put_line("Entrez deux entiers"); Get(N); Get(M); New_Line; Put("Le pgcd est "); Put(Pgcd(N,M)); end Main;

Bibliographie
Le livre : Cours Ada 95 . Le livre : apprendre a programmer avec ada - site du zro - .