Memento ADA

Université Joseph Fourier
UE INF234
DLST
Année 2015/2016
Mémento ADA
Mots-clés, identificateurs et noms des fichiers ADA
Les mots-clés du langage ADA (ne pouvant pas être utilisés comme identificateurs) sont :
abort
abs
abstract
accept
access
aliased
all
and
array
at
begin
body
case
constant
declare
delay
delta
digits
do
else
elsif
end
entry
exception
exit
for
function
generic
goto
if
in
interface
is
limited
loop
mod
new
not
null
of
or
others
out
overriding
package
pragma
private
procedure
protected
raise
range
record
rem
renames
raise
range
record
rem
renames
requeue
return
reverse
select
separate
some
subtype
synchronised
tagged
task
terminate
then
type
until
use
when
while
with
xor
Les identificateurs suivants représentent des noms de types et variables standards en ADA
boolean true false
integer natural positive
short_short_integer short_integer long_long_integer long_integer
float short_float long_float long_long_float duration
character wide_character string wide_string
constraint_error program_error storage_error tasking_error
Un identificateur (nom de variable, de type, de fonction, de procédure, de paquetage) est une chaı̂ne de caractères
composée de lettres, éventuellement de caractères souligné , de chiffres.
Le premier caractère est une lettre, deux caractères ne peuvent être consécutifs et le dernier caractère ne peut pas être
Le langage ADA ne distingue pas majuscule et minuscule.
Le nom d’un fichier (sans l’extension .ads ou .adb) doit correspondre au nom du paquetage ou de la procédure
principale mais sans utiliser de lettres majuscules.
L’extension .adb est utilisée pour le corps d’un paquetage ou d’une procédure principale.
L’extension .ads est utilisée pour la spécification d’un paquetage.
Opérateurs
Les opérateurs suivants sont triés par ordre décroissant de priorité :
1)
2)
3)
4)
5)
6)
**
not
abs
puissance
négation
valeur absolue
*
/
mod
rem
multiplication
division
modulo
reste
+
-
signe plus
signe moins
+
-
&
addition
soustraction
concaténation
=
<=
>=
/=
<
>
égal à
inférieur ou égal
supérieur ou égal
différent de
inférieur strict
supérieur strict
and
or
xor
et
ou
ou exclusif
Dans une expression, les opérateurs de même priorité sont évalués de gauche à droite.
Utiliser les parenthèses ( ) pour effectuer une opération en priorité ou en cas de doute sur une priorité.
Opérateurs booléens conditionnels
Il existe deux opérateurs booléens conditionnels, pour chacun le second opérande est évalué si et seulement si le
premier a une certaine valeur.
exp1 and then exp2
exp2 est évaluée si et seulement si exp1 est vrai
Exemple :
i<=10 and then T(i)/=0
exp1 or else exp2
exp2 est évaluée si et seulement si exp1 est faux
Exemple :
b==0 or else a/b > 1
Lecture et écriture de “fichiers texte” depuis un programme ADA
Dans la terminologie Ada un fichier texte est un fichier de caractères auquel on accède de manière séquentielle. Des
procédures et fonctions d’accès sont fournies par des paquetages prédéfinis comme Ada.Text IO, Ada.Integer Text IO
ou Ada.Float Text IO. Notons que les périphériques d’entrée-sortie “standard” (comme le clavier et l’écran) sont
considérés comme des fichiers texte particuliers. Nous décrivons ci-dessous certaines procédures et fonctions d’accès à
des fichiers texte.
Toute opération d’entrée/sortie sur un fichier consiste en :
1) l’ouverture du fichier,
2) des opérations de lecture / écriture dans le fichier,
3) la fermeture du fichier.
Pour lire au clavier ou écrire à l’écran, on utilise les procédures et fonctions d’accès de la partie 2) en omettant le
premier paramètre.
Différentes erreurs peuvent se produire lors de l’exécution des procédures et fonctions suivantes (par exemple un
fichier externe inexistant ou impossible à créer, une valeur impossible à lire, . . .).
Lorsque de telles erreurs se produisent des exceptions particulières sont levées.
• • •
1) Ouverture de fichiers
Comme beaucoup de langages, Ada distingue :
– le fichier externe, stocké par exemple sur le disque dur de la machine, et que l’on connait par son nom (une
chaı̂ne de caractères) ;
– le descripteur interne, qui est une structure de données manipulée par le programme Ada et dont le type (privé)
est File Type.
Ouvrir un fichier depuis un programme Ada revient donc à associer un descripteur interne à un fichier externe. Cela
peut se faire par exemple avec les primitives (simplifiées) suivantes :
procedure Create (File : in out File Type; Mode : in File Mode; Name : in String);
Cette procédure crée un fichier externe de nom Name et lui associe le descripteur interne File. Le Mode est
Out File pour permettre un accès ultérieur en écriture. Si le fichier externe existait déjà, il est écrasé.
procedure Open (File : in out File Type; Mode : in File Mode; Name : in String);
Cette procédure ouvre un fichier externe (supposé exister) de nom Name et lui associe le descripteur interne
File. Le Mode est In File pour permettre un accès ultérieur en lecture.
En général, on utilise Open pour lire un fichier (existant) et Create pour écrire un (nouveau) fichier (s’il existe déjà,
il est écrasé).
Ces procédures sont définies dans le paquetage Ada.Text IO.
• • •
Lorsqu’un fichier a été ouvert en mode In File (respectivement Out File) il est possible d’y effectuer des opérations
de lecture (respectivement d’écriture).
2-a) Opérations de lecture / écriture de caractères
On peut lire (resp. écrire) un fichier texte caractère par caractère.
procedure Get(File : in File Type; Item : out Character);
Cette procédure permet de lire le prochain caractère dans le fichier associé au descripteur File et de le mémoriser
dans Item, les caractères de fin-de-ligne sont ignorés.
procedure Skip line(File : in File Type);
Cette procédure permet d’avancer dans le fichier associé au descripteur File jusqu’au premier caractère suivant
un caractère fin-de-ligne.
procedure Put(File : in File Type; Item : in Character);
Cette procédure permet d’écrire le caractère Item en séquence dans le fichier associé au descripteur File.
procedure New Line(File : in File Type);
Cette procédure permet d’écrire un caractère fin-de-ligne en séquence dans le fichier associé au descripteur File.
Ces procédures sont définies dans le paquetage Ada.Text IO.
2-b) Opérations de lecture / écriture de chaı̂nes de caractères
On peut lire (resp. écrire) un fichier texte ligne par ligne.
procedure Get Line(File : in File Type; Item : out String; Last : out Natural);
Cette procédure permet de lire la chaı̂ne de caractère terminée par le prochain caractère fin-de-ligne dans le
fichier associé au descripteur File et de la mémoriser dans Item. L’entier Last indique le nombre de caractères
lus. Item doit avoir une taille suffisante (sinon une exception sera levée).
Remarque : après l’exécution de l’instruction Get Line, le descripteur de fichier se trouve en début de la ligne
suivante.
procedure Put Line(File : in File Type; Item : in String);
Cette procédure permet d’écrire la chaı̂ne de caractère Item en séquence dans le fichier associé au descripteur
File, suivie d’un caractère fin-de-ligne. Lors de l’appel à Put Line, il faut préciser l’intervalle d’indices de la
chaı̂ne Item : par exemple Put line(fich, chaine(1..15)) .
Ces procédures sont définies dans le paquetage Ada.Text IO.
2-c) Opérations de lecture / écriture d’entiers ou réels flottants
procedure Get(File : in File Type; Item : out Integer);
procedure Get(File : in File Type; Item : out Float);
Cette procédure permet de lire le prochain entier (ou réel flottant) dans le fichier associé au descripteur File,
après avoir ignoré tous les caractères espace, tabulation ou fin-de-ligne éventuels le précédant.
Remarque : la présence d’un caractère invalide (caractère non numérique) produit une erreur.
procedure Put(File : in File Type; Item : in Integer);
procedure Put(File : in File Type; Item : in Integer; W : in Natural);
Cette procédure permet d’écrire l’entier Item en séquence dans le fichier associé au descripteur File sur Width
caractères (par défaut Width = 10).
procedure Put(File : in File Type; Item : in Float);
procedure Put(File : in File Type; Item : in Float; Fore, Aft, Exp : in Natural);
Cette procédure permet d’écrire le réel flottant Item en séquence dans le fichier associé au descripteur File avec
Fore caractères avant la virgule, Aft chiffres après la virgule et Exp caractères pour la partie exposant (puissance
de 10) (par défaut Fore = 2, Aft = 7 et Exp = 3).
Ces procédures sont définies dans le paquetage Ada.Integer Text IO pour les entiers
et Ada.Float Text IO pour les réels flottants.
2-d) Opérations de test de fin de ligne ou fichier
function End Of Line(File : in File Type) return Boolean;
Cette fonction renvoie True si et seulement si le prochain caractère dans le fichier associé au descripteur File
est un caractère fin-de-ligne.
function End Of File(File : in File Type) return Boolean;
Cette fonction renvoie True si la fin de fichier est atteinte.
Ces fonctions sont définies dans le paquetage Ada.Text IO.
• • •
3) Fermeture de fichiers
Une fois les différentes opérations faites sur un descripteur interne, celui-ci doit être fermé :
procedure Close(File : in out File Type);
Cette procédure ferme le fichier externe associé au descripteur interne File.
Cette procédure est définie dans le paquetage Ada.Text IO.
Tableaux
Un type tableau se définit à l’aide du mot-clé array. Les instructions suivantes montrent quelques exemples de
définitions et d’utilisations de tableaux en ADA :
−− t y p e t a b l e a u de r é e l s a v e c i n d i c e s ( non c o n t r a i n t s ) p o s i t i f s ou n u l s
type T a b l e a u R e e l s i s array ( n a t u r a l range <>) of f l o a t ;
−− t y p e s t a b l e a u x a v e c i n d i c e s c o n t r a i n t s
subtype Dim i s i n t e g e r range 1 . . 1 0 0 ;
−−
type Tableau100 i s array (Dim) of f l o a t ; −−
type Tableau7 i s array ( 0 . . 6 ) of f l o a t ; −−
type T r i p l e t i s new T a b l e a u R e e l s ( 1 . . 3 ) ; −−
type
type
type
type
e n t i e r c o n t r a i n t e n t r e 1 e t 100
t a b l e a u a v e c i n d i c e c o n t r a i n t e n t r e 1 e t 100
t a b l e a u avec i n d i c e c o n t r a i n t entre 0 e t 6
t a b l e a u avec i n d i c e c o n t r a i n t entre 1 e t 3
T1 , T2 , T3 : Tableau7 ;
A : Tableau100 ;
B : TableauReels ( 0 . . 9 9 9 9 ) ;
...
−− i n i t i a l i s e r l e s v a l e u r s d ’ un t a b l e a u
T1 := ( 0 . 0 , 6 . 0 , 2 . 5 , 3 . 0 , 3 . 8 , −2.62 , 1 . 8 8 e −5);
T2 := ( others => 0 . 0 ) ; −− t o u s l e s é lé m e n t s égaux à 0 . 0
A := (2= >1.0 , 4= >1.0 , others = >0.0); −− l e s é l e m e n t s d ’ i n d i c e s 2 e t 4 égaux à 1 . 0
−− e t l e s a u t r e s égaux à 0 . 0
−− p a r c o u r s d e s é lé m e n t s d ’ un t a b l e a u s a n s c o n n a i t r e a p r i o r i s e s b o r n e s
f o r i n d i c e in T1 ’ f i r s t . . T1 ’ l a s t loop
put ( T1 ( i n d i c e ) ) ; n e w l i n e ; −− e c r i r e une v a l e u r par l i g n e
end loop ;
f o r k in A’ range loop
put (A( k ) ) ; n e w l i n e ; −− e c r i r e une v a l e u r par l i g n e
end loop ;
−− c o p i e d ’ un t a b l e a u en e n t i e r ou d ’ une p a r t i e s e u l e m e n t dans un a u t r e
T1 := T2 ;
T3 ( 2 . . 5 ) := T1 ( 0 . . 3 ) ; −−
T3( 2 ) : =T1 ( 0 ) ; T3( 3 ) : =T1 ( 1 ) ; T3( 4 ) : =T1 ( 2 ) ; T3( 5 ) : =T1 ( 3 ) ;