Subprog
Subprog permet de déclarer un sous-programme pouvant comporter une liste d'arguments, appelable par Call.
Syntaxe
Subprog sous_prog [ '(' liste_args ')' ]
Paramètres
Elément | Description | Restrictions |
sous_prog | nom_d'OBJet désignant le sous-programme. | Aucune. |
liste_args | Liste de nom_de_variables séparés par le caractère ','. | Les arguments doivent avoir des noms distincts. |
Exemples
# Appel d'un sous-programme d'incrémentation de compteur dans le
# traitement courant
Call INCR_CPT(10,OK)
...
# Un peu plus loin dans le même traitement...
SubprogINCR_CPT(DELTA,ST)
Value Integer DELTA
Variable Libelle ST
Lock COMPTEUR With lockwait = 5
ST = [S]fstat
If ! ST
[C]COMPTEUR += DELTA
Unlock COMPTEUR
Endif
End
Description
Un sous-programme déclaré par l'instruction Subprog se terminera par l'instruction End. En effet, son exécution, déclenchée à l'appel d'un Call, se termine dès qu'une instruction End est rencontrée. Puis, le traitement ayant appelé ce sous-programme reprend la main à l'instruction qui suit ce Call.
Lorsque le sous-programme comporte des arguments, il est possible, mais non impératif, de les déclarer (tous ou en partie) à la suite de l'instruction Subprog. L'ordre dans lequel on le fait n'a pas à suivre celui de l'instruction Subprog.
Outre leur type et dimension, on précisera s'ils sont passés par adresse ou par valeur en utilisant un des mots-clés suivant :
- Value signifie que l'argument est passé par valeur et recopié dans la variable local du sous-programme créée à cet effet. Ce sera le mode par défaut quand l'argument passé est une expression. Un argument passé par valeur n'est donc pas modifié par le sous-programme. Ce mode est gourmand en place mémoire et en temps d'exécution.
- Variable signifie que l'argument passé par adresse. La variable locale créée pointe sur la variable passée en paramètre qui pourra donc être modifiée par le sous-programme.
- Const signifie que l'argument passé l'est par adresse mais que la variable locale créée ne sera pas modifiable (ni affectable). C'est le mode par défaut quand l'argument passé est une variable.
On peut utiliser comme type d'arguments les mêmes que pour les variables (Libelle, Shortint, Integer, Date, Decimal et Char).
Par défaut, le type sera :
- Integer si l'argument est de type Libelle, Shortint ou Integer;
- du même type que l'argument dans les autres cas.
Exemple :
Local Integer A
A = 1
Call EXP1(A,2,3)
End
Subprog EXP1(A,B,C)
Variable Integer A
Value Integer B, C
Infbox num$(type(A))-num$(A)-num$(B)-num$(C): # on affichera 4 1 2 3
End
La longueur des arguments de type Char ne sera pas précisée. On se contentera de faire suivre le nom de l'argument par (). La longueur de la variable locale sera celle de l'argument passé par Call.
Après le type, il est indispensable de préciser la dimension s'il y en a une, en utilisant les caractères "(" et ")". Pour déclarer plusieurs dimensions il faudra utiliser des virgules pour les séparer.
Exemple : Value Decimal MAT(,) déclare un tableau bi-dimensionné de nombres DCB dont les tailles dépendront de l'argument passé par Call et dont les bornes inférieures seront 0 pour les 2 dimensions.
Par défaut - c'est à dire si on ne précise rien - la taille de chaque dimension sera celle de l'argument et sa borne inférieure sera 0. On peut préciser la taille de chaque dimension par une expression à valeur entiére ou une variable passée elle aussi en paramètre. Dans ce dernier cas, cette variable devra impérativement être déclarée avant.
Exemple : Variable Char ARGS () (AC,GV)
déclare une tableau bi-dimensionné de chaine de caractères, la première dimension allant de 0 à AC - 1, la deuxième de 0 à GV -1.
On pourra préciser la borne inférieure. Si on a précisé la borne inférieure, on pourra aussi préciser la borne supérieure. Si on ne le fait pas, la taille résultante sera celle de l'argument. Ces bornes pourront être des expressions à valeur entière, des variables. Les bornes inférieures seront suivies de "..".
Exemple : Value Integer CUB(N11..,N21..N22,) déclare un tableau d'entiers à trois dimensions, indicé à partir de N11 pour la première, de N21 à N22 pour la deuxième et à partir de 0 pour la troisième.
Si on précise des bornes, ces bornes n'ont pas à être identiques à celles des arguments des traitements appelants, l'élément de plus petit indice de l'argument du Call sera associé à (ou recopié dans) l'élément de plus petit indice de la variable locale du sous-programme et ainsi de suite.
Exemple :
Integer T(1..M, 3..N)
Call SP(T)
Subprog SP (TAB2)
Value Integer TAB2(,)
Dans ce cas l'élément TAB2(0,0) pointera sur T(1,3) etc.
Au lancement d'un sous-programme, une classe de variable locale est crée. Les variables déclarées dans le sous-programme seront par défaut de cette classe. Elle sera automatiquement détruite par le End final.
Un sous-programme peut accéder, pendant son exécution, aux variables globales et aux OBJets Adonix des traitements appelants. Pour ne pas modifier le contexte, au retour du sous-programme appelé par Call, on déclarera les OBJets propres à ce sous-programme en mode Local (Local File, Local Mask, Local Mesbox, Local Inpbox ). Ils seront automatiquement refermés par le End final.
Remarques
La création d'une classe locale fait qu'un sous-programme appelé par Call est toujours plus long à exécuter qu'une étiquette appelée par Gosub. Les sous-programmes permettent par contre une meilleure modularité et une meilleure lisibilité.
Pendant l'exécution d'un sous-programme, les informations suivantes sont conservées :
- les variables système Adonix et globales,
- les fichiers, masques et boites de dialogues ouverts,
- les fichiers séquentiels ouverts,
- les listes de classes par défaut (sauf la classe locale),
- le fait d'être en mode Inter ou Nointer,
- le fait d'avoir initié une transaction.
Par contre sont perdus :
- la classe de variables locales,
- l'étiquette associée à Onerrgo, ainsi que celle associée à Onintgo.
D'autre part, un sous-programme ne peut pas terminer une transaction qu'il n'aurait pas lui-même initiée.