-
Notifications
You must be signed in to change notification settings - Fork 0
/
p_esiut.ads
182 lines (149 loc) · 7.95 KB
/
p_esiut.ads
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
--*************************************
-- auteur Daniel Feneuille I.U.T. Aix *
--*************************************
--*** modifié par Laetitia Racault pour rajouter :
-- ecrire_ligne sur les caractères et les énumérés
-- et les procédures lire/ecrire sur les booléens
--*** modifie par Anne Lejeune pour ameliorer la fonction IMAGE pour les flottants
--=======================
-- partie SPECIFICATIONS
--=======================
--
with TEXT_IO;
package p_esiut is
--==============================================
-- Procedures d'entres/sorties sur les entiers
--==============================================
procedure ECRIRE(L_ENTIER : in integer);
-- permet d'ecrire un entier sur la ligne a partir de la position
-- initiale du curseur.
procedure ECRIRE_LIGNE(L_ENTIER : in integer);
-- c'est ECRIRE + A_LA_LIGNE
procedure LIRE(L_ENTIER : out integer);
-- permet de lire un INTEGER dans une base quelconque (2 a 16) avec
-- validation (on recommence jusqu'a ce qu'il soit valable)
--===============================================
-- Procedures d'entres/sorties sur les flottants
--===============================================
procedure ECRIRE(LE_REEL : in FLOAT);
-- permet d'ecrire un FLOAT sur la ligne a partir de la position
-- initiale du curseur. Si l'on souhaite aller a la ligne ensuite
-- utiliser en plus la procedure A_LA_LIGNE. Le reel est ecrit sous
-- la forme: signe, partie entiere, point decimal et partie decimale
-- le point decimal est toujours present, le signe + est remplace par
-- un espace. Quant aux deux champs numeriques ils suppriment les
-- zeros non significatifs.
procedure ECRIRE_LIGNE(LE_REEL : in FLOAT);
-- c'est ECRIRE + A_LA_LIGNE
procedure LIRE(LE_REEL : out FLOAT);
-- permet de lire un FLOAT dans une base quelconque (2 a 16) avec
-- validation (on recommence jusqu'a ce qu'il soit valable). Le point
-- decimal est obligatoire a la saisie.
--=================================================
-- Procedures d'entrees/sorties sur les caracteres
--=================================================
procedure ECRIRE ( CARAC : CHARACTER)
renames TEXT_IO.PUT;
-- permet d'ecrire un caractere sur la ligne a partir de la position
-- initiale du curseur.
procedure ECRIRE_LIGNE(CARAC : CHARACTER); --***
-- c'est ECRIRE + A_LA_LIGNE
procedure LIRE ( CARAC : out CHARACTER);
-- permet de lire un caractere unique. La lecture est tamponnee c'est-
-- a-dire que l'on peut effacer le caractere saisi d'ou la necessite de
-- terminer la saisie par un RC (appui sur la touche entree). Le
-- tampon est purge apres la prise en compte de ce caractere.
--===============================================================
-- Procedures d'entrees/sorties sur les chaines de caracteres ADA
--===============================================================
procedure ECRIRE( LA_CHAINE : STRING)
renames TEXT_IO.PUT;
-- permet d'ecrire une chaine de caracteres sur la ligne a partir
-- de la position initiale du curseur. Si l'on souhaite aller a la
-- ligne utilisez plutot la procedure ECRIRE_LIGNE.
procedure LIRE( LA_CHAINE : out STRING);
-- permet de saisir une frappe de caracteres terminee par entree
-- si le nombre de caracteres est inferieur a la dimension du STRING
-- passe en parametre le complement est initialise a espace.
-- Le tampon est purge.
procedure LIRE_TRANCHE( LA_CHAINE : out STRING; LONG : out natural) ;
-- permet de saisir une frappe de caracteres terminee par entree.
-- le nombre de caracteres tapes est passe en parametre. Seule la
-- tranche 1..LONG est valide, le reste des caracteres n'est pas
-- initialise a espace. Le tampon est purge.
procedure ECRIRE_LIGNE( LA_CHAINE : STRING)
renames TEXT_IO.PUT_LINE;
-- c'est ECRIRE + A_LA_LIGNE
--==============================================
-- ***Procedures d'entres/sorties sur les booléens
--==============================================
procedure ECRIRE(LE_BOOL : in boolean);
-- permet d'ecrire un BOOLEAN sur la ligne a partir de la position
-- initiale du curseur.
procedure ECRIRE_LIGNE(LE_BOOL : in boolean);
-- c'est ECRIRE + A_LA_LIGNE
procedure LIRE(LE_BOOL : out boolean);
-- permet de lire un BOOLEAN
--=========================================================
-- Procedures vider clavier et saut a la ligne sur l'ecran
--=========================================================
procedure VIDER_TAMPON;
-- peu utile dans le contexte propose ici puisque toutes les saisies
-- sont purgees. Permet cependant d'attendre la frappe de la touche
-- entree. C'est une pause (voir ci-dessous) sans message.
procedure A_LA_LIGNE( NOMBRE : TEXT_IO.POSITIVE_COUNT:=1)
renames TEXT_IO.NEW_LINE;
-- sans commentaire
procedure PAUSE;
-- affiche le traditionnel message: "appuyez sur Entree pour continuer"
-- et attend la frappe sur la touche entree.
procedure CLR_ECRAN;
-- efface le contenu de la fenetre (l'ecran)
--=======================================================================
-- Transformation de Reel, d'entier ou de booléen en Chaine de caracteres
--=======================================================================
function IMAGE (L_ENTIER : in INTEGER) return STRING;
-- c'est une redefinition de l'attribut c'est-a-dire INTEGER'IMAGE
function IMAGE (LE_REEL : in FLOAT) return STRING;
-- permet un affichage des réels plus accessible à l'humain que celui
-- fourni par l'attribut image du type float (écriture scientifique
-- l'image est celle definie dans la procedure ECRIRE avec FLOAT.
function IMAGE (LE_BOOL : in BOOLEAN) return STRING;
-- NEW - 2019
-- affiche la chaîne "TRUE" ou "FALSE" suivant la valeur de LE_BOOL
--=======================================================================
-- Special type enumeratif paquetage "interne" et generique
--=======================================================================
generic
type T_ENUM is (<>);
package P_ENUM is
-- le type enumeratif ne pouvant etre fixe a priori, comme c'etait le cas
-- pour les numeriques, ou le choix INTEGER et FLOAT s'imposait, T_ENUM
-- doit etre variable donc parametre d'ou la genericite incontournable.
--
-- Modele de declaration dans la procedure utilisatrice (2 lignes):
-- package MON_ENUM is new P_E_SORTIE.P_ENUM(vrai_type_enumeratif);
-- use MON_ENUM;
function IMAGE (L_ENUM : in T_ENUM) return STRING;
-- utilisation: IMAGE(variable_du_vrai_type_instancie ou constante)
-- ce string peut etre utilise dans un ECRIRE ou ECRIRE_LIGNE ce qui
-- permet des ecritures d'images d'objets de type different ainsi:
-- ECRIRE_LIGNE(IMAGE(...)&IMAGE(...)&...etc);
procedure LIRE (L_ENUM : out T_ENUM);
-- cette procedure controle le type. On recommence jusqu'au succes.
-- utilisation: LIRE(variable_du_vrai_type_instancie);
procedure ECRIRE (L_ENUM : in T_ENUM);
-- La valeur de la variable est affichee en majuscules.
-- utilisation: ECRIRE(variable_du_vrai_type_instancie ou constante);
procedure ECRIRE_LIGNE(L_ENUM : in T_ENUM); --***
-- c'est ECRIRE + A_LA_LIGNE
end P_ENUM; -- fin du paquetage interne et generique
--=========================
-- Special type acces paquetage "interne" et generique
--=========================
generic
type mon_type is private;
type t_acces is access mon_type;
procedure ecrire_acc(a : in t_acces);
-- 9/05
end p_esiut; -- fin des specifications du paquetage d'Entrees-Sorties