Funprog
Funprog permet de déclarer une fonction, appelable par func, et pouvant comporter une liste d'arguments, et envoyer un résultat .
Syntaxe
Funprog fonction [ '(' liste_args ')' ]
Paramètres
Elément | Description | Restrictions |
fonction | nom_d'OBJet désignant la fonction. | Aucune. |
liste_args | Liste de nom_de_variables séparés par le caractère ','. | Les arguments doivent avoir des noms distincts. |
Exemples
# Appel de la fonction de calcul X du traitement ZETRT
# RESULT donnera le nombre 22
Local Integer RESULT
RESULT = 4*(func ZETRT.X(3,2) + 1)
End
# la fonction de calcul X du traitement ZETRT
Funprog X(A,B)
Value Integer A
Value Integer B
End A*A/B
# la fonction restituant le statut actif ou inactif d'un code activité
# et son dimensionnement
Funprog ACTIV(COD)
Value Char COD
If COD="" : End 1 : Endif
If clalev([F:ACV])=0 : Local File ACTIV [ACV] : Endif
Read [ACV]CODACT = COD
If fstat or [F:ACV]FLACT<>2
End 0
Elsif [F:ACV]TYP=2
End [F:ACV]DIME
Else
End 1
Endif
Description
Une fonction déclarée par l'instruction Funprog se terminera par l'instruction End. En effet, son exécution, déclenchée à l'appel d'un func se termine dès qu'une instruction End est rencontrée. Puis, le traitement ayant appelé cette fonction reprend la main à l'instruction qui suit ce func, puis pourra utiliser le résultat de l'expression précisée dans l'einstruction End de la fonction.
Lorsque la fonction comporte des arguments, il est possible, mais non impératif, de les déclarer (tous ou en partie) à la suite de l'instruction Funprog. L'ordre dans lequel on le fait n'a pas à suivre celui de l'instruction Funprog.
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 de la fonction 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 la fonction. 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 la fonction.
- 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.
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 func.
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 func 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 func sera associé à (ou recopié dans) l'élément de plus petit indice de la variable locale de la fonction et ainsi de suite.
Exemple :
Integer T(1..M, 3..N)
func SP(T)
Funprog SP (TAB2)
Value Integer TAB2(,)
Dans ce cas l'élément TAB2(0,0) pointera sur T(1,3) etc.
Au lancement d'une fonction, une classe de variable locale est crée. Les variables déclarées dans la fonction seront par défaut de cette classe. Elle sera automatiquement détruite par le End final.
Une fonction 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 de la fonction appelé par func, on déclarera les OBJets propres à cette fonction en mode Local (Local File, Local Mask, Local Mesbox, Local Inpbox ). Ils seront automatiquement refermés par le End final.
Remarques
Pendant l'exécution d'une fonction, 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, une fonction ne peut pas terminer une transaction qu'il n'aurait pas lui-même initiée.