Bonjour,
 
Voilà le problème, j'ai un fichier principal 'proceduremain.adb' qui contient une procédure 'proceduremain' avec plusieurs choix possibles pour l'utilisateur:
Si l'utilisateur tape '1' il exécute une procédure 'procedure1' (sans paramètres) qui se trouve dans le fichier 'procedure1.adb'. Cette procédure marche de façon "autonome".
Si l'utilisateur tape '2' il exécute une procédure 'procedure2' (sans paramètres) qui se trouve dans le fichier 'procedure2.adb'. Cette procédure marche de façon "autonome".
...
etc
Est-ce que quelqu'un pourrait m'expliquer comment implémenter les procédures autonomes 'procedure1', 'procedure2', ...,etc. dans la procédure principale 'proceduremain', s'il vous plaît ?
(C'est un peu comme si on faisait un 'include' d'une procédure externe au sein de son prog principal, je crois !)
 
 
Merci,
 
loucki

Clause with....

procedure proceduremain is
procedure procedure1 is separate;
procedure procedure2 is separate;
begin
   null; --appel procedure1,procedure2
end;
 
-----------------------------------------------
procedure procedure1 is
separate (proceduremain)
begin
   null;
end procedure1;
 
idem pour procedure2

La syntaxe du separate est fausse :
Exemple:
 
Dans "principale.adb" :

Puis dans "principale-truc.adb" :

De plus ce n'était pas la réponse à la question posée.
Là jovalise, tu implémente un sous-programme séparemment alors que loucki demandait un equivalent de procedure externe.
 
'Separate ' veut dire qu'on compile séparemment du sous-programme principal un autre sous programme qui est sémantiquement inclu dans le sous-programme principal : on peut d'ailleurs lui passer des paramètres.
 
Ce que demandait loucki, c'était juste de pouvoir utiliser dans son prog d'autres prog " qui s'exécutent de façon autonome ".
D'où ma réponse "clause with".

j'avais cru comprendre, tu m'excusera pour les faute d'orthographe, que ca revenai au même puisque with, c'est mon avis, fais la même chose,  
 
[citation]compile séparemment[/citation]
 
Ou alors c'est carement un truc du genre "import"

Non, c'est pas du tout pareil.
 
En fait, tu utilise la compilation séparée dans 2 cas :
1) Quand tu as un sous-programme de taille importante qui risque de rendre ton code lourd à comprendre, tu rend ton sous-programme "separate".
Si le nom de ce sous-programme est assez explicite, ton prog principal sera beaucoup plus facile à comprendre sans les 300 lignes d'une méthode s'appelant par exemple "trier", et dont le nom suffit à comprendre ce qu'elle fait.
 
2) Si ton sous-programme est le seul à nécessiter la compilation avec d'autre bibliothèques par exemple ada.numerics.* ... tu peut rajouter les with et les use dans le fichier séparé, ce qui rend plus clair (pour celui qui lit le code) la compilation avec ces paquetages: on comprend directe pour qui servent ces with...
 
Pour rajouter une remarque au 1), tu peut considérer le cas suivant:
Imagine que le programme que tu écrit contient une ou deux très grosses fonctions ou procedures et que celles-ci sont validées, càd que tu sait qu'elles marchent.
Cependant, le reste est en débuggage, et tu recompile sans arret en ajoutant des modifs (ça doit t'arriver svt non?).
Et bien en extrayant ces sous-programmes volumineux de ton "main", tu recompileras plus vite celui-ci car les sous-programmes extraits n'aurront pas à être recompilé.
Juste une édition de lien sera nécessaire, et t'aurras moins à attendre pour peut que ta config est légère.
 
Voilà à quoi ça sert la compil séparée, à dégraisser l'mammouth !

Par contre, écrire:
with Ma_Fontion;
.....
 
Est complètement différent.
Dans ce cas, Ma_fonction est contenu dans un fichier (ma_fonction.adb) et n'a aucun rapport avec ton programme, en particulier elle ne peut utiliser les types et méthodes que tu y déclare, alors que les sous-prog compilés séparemment le peuvent (puisque c'est comme si ils étaient à l'intérieur du main), pour peut qu'ils aient étés déclarés après ces types ou méthodes bien sur.
 
Voilà, j'espère que tu y voit un peut plus clair maintenant.