Salut tout le monde.
J’ai remarqué une certaine confusion dans la compréhension du fonctionnement de sous-programmes.
Je vous propose, ici, une petite explication de la chose.
J’espère qu’elle éclairerait certaines lanternes.
Un sous-programme est une partie indépendante d’un programme principal ou des autres sous-programmes.
Sa tâche doit être parfaitement définie. Il est souhaitable qu’il soit indépendant du corps principal du programme.
Chaque fois que vous l’appelez, les instructions de la routine sont exécutées comme si elles figuraient à l’emplacement du nom des sous-programmes dans le corps principal.
L’indépendance d’un sous-programme permet en plus de l’intégrer dans d’autres programmes.
Il est inutile de réinventer, à chaque fois, la roue !
En général, il existe 2 types de sous-programmes : les procédures et les fonctions.
Actuellement PANORAMIC connait les procédures et j’espère que les fonctions ne vont pas tarder !
La distinction fondamentale entre procédure et fonction se base sur le fait qu’une fonction retourne TOUJOURS une valeur à l’appelant.
Cela n’a rien de systématique dans le cas des procédures, elles réalisent des tâches diverses.
Variables locales et globales :
====================
Le qualificatif de « global », lorsqu’il est appliqué à un identificateur ou une variable indique que le symbole est accessible à la totalité du programme, y compris la totalité des sous-programmes. Lorsqu’une variable est déclarée dans le programme principal (c.à.d. en dehors des sous-programmes), il s’agit d’une variable globale.
Par contre, un symbole « local » n’est connu que du sous-programme où il est déclaré par DIM_LOCAL, et non des autres sous-programmes ni du programme principal.
Cela signifie que ces derniers ne peuvent en exploiter le contenu.
PANORAMIC autorise la déclaration d’un identificateur à la fois en tant que symbole local et global.
Le symbole local est alors PRIORITAIRE sur le symbole global.
Exemple :
La variable globale X déclarée dans le programme principal n’est accessible à un sous-programme que s’il ne déclare pas lui-même une variable X.
Si c’est le cas, les opérations exploitant X se réaliseront avec le contenu de la variable locale X. La variable globale de même nom ne sera ni prise en compte ni modifiée.
Utilisez tant que faire se peut des variables locales dans vos sous-programmes. Vos routines deviennent alors relativement indépendantes du programme principal, ce qui vous permet de les reprendre dans d’autres programmes.
Transmission par valeur de paramètres à une procédure
==========================================
PANORAMIC permet de transmettre des valeurs de l’appelant (programme principal ou sous-programme) à la procédure appelée.
La procédure traitera ensuite les valeurs reçues. Cela augmente les possibilités de réemploi d’un sous-programme, chaque programme pouvant transmettre des valeurs propres à la routine. De même, au sein d’un seul programme les appels peuvent se multiplier, car ils se distinguent par la transmission de valeurs différentes.
La déclaration d’une procédure avec transmission par valeur de paramètres se fait avec une liste de paramètres entre parenthèses qui suit le nom de la procédure. Cette liste énumère les valeurs à transmettre ainsi que leur type.
exp :
SUB NomProcedure(<liste des paramètres>)
…
…
END_SUB
Admettons qu’une procédure TEST reçoive 2 valeurs A% et B% de type entier. Voici un exemple de déclaration :
SUB test(A%,B%)
…
END_SUB
Si, la procédure TEST devait en plus recevoir une valeur C$ de type chaine, la déclaration deviendrait :
SUB test(A%,B%,C$)
…
END_SUB
Une fois cette dernière déclaration effectuée, la procédure TEST sera appelée en lui transmettant très précisément 2 valeurs de type entier et une valeur de type string, STRICTEMENT DANS CET ORDRE.
A%, B%,C$ seront traités comme des variables locales à la procédure TEST. Elles reçoivent les valeurs transmises. Ce sera au travers de ces noms que vous traiterez les valeurs dans la procédure.
Le système affectera la 1ère valeur reçue à la variable A%, la seconde à B%, et la troisième à C$.
Voici un exemple de la manière dont nous appellerons la procédure TEST à partir d’un programme :
test(2,3, "salut")
Ce qui entrainerait les affectations :
A% < ---- 2
B% < ----3
C$ < ---- "salut"
REMARQUE :
L’expression « transmission par valeur » ne signifie pas que nous devons explicitement préciser la valeur car la transmission peut également porter sur des variables contenant la valeur. Mais précisons que seule la valeur, c.à.d. l’information contenue par la variable est alors transmise.
Un programme qui utiliserait « également les variables A%,B% et C$ (qui sont ici globales) et leur affecterait des valeurs, pourrait appeler la procédure TEST de la manière suivante :
…
A% = 2 : B% = 3 : C$ = "salut"
test(a%,b%,c$)
…
L’effet serait semblable à celui de l’exemple précédent. La procédure reçoit les valeurs 2,3 et "salut" et les stocke dans les variables locales A%,B% et C$.
Les identificateurs globaux ne doivent pas à tout prix être les mêmes que les symboles locaux.
Un programme qui utiliserait les variables X%,Y% et Z$, pourait appeler la procédure TEST de la manière suivante :
…
X% = 2 : Y% = 3 : Z$ = "salut"
test(X%,Y%,Z$)
Présentons ce que nous venons de dire d’une manière condensée.
Considérons comme acquises une déclaration et une affectation cohérente des variables, les appels de la procédure TEST, ci-dessous ont tous le même effet :
test(2,3, "salut")
test(a%,b%,c$)
test(x%,y%,z$)
PANORAMIC dépose sur la pile (la pile est une zone de la mémoire vive) une COPIE de chaque paramètre de type « valeur » transmis.
Une fois la routine exécutée, lors du retour au programme appelant, le système ELIMINERA les paramètres de la pile. Ces valeurs sont en fait des COPIES TEMPORAIRES, les valeurs d’origines connues du programme appelant NE SONT PAS MODIFIEES par l’exécution de la procédure.
Transmissions de paramètres par adresse
===============================
La version actuelle de PANORAMIC ne permet pas la transmission de paramètre par adresse.
Lorsque cela sera possible, je vous donnerais les informations utiles.
LES FONCTIONS
============
Dans la version actuelle, les déclarations de sous-programmes de type FONCTION n’est pas encore implémentée.
Disons simplement ceci :
Les fonctions ne se distinguent de procédures que par le fait qu’elles retournent systématiquement un résultat au programme appelant, ce qui permet de les utiliser dans des expressions.
La transmission de paramètres par valeur et par adresse se réalise, pour les fonctions, strictement de la même manière que pour les procédures.
Nous en parlerons peut-être une autre fois.
J’espère que j’ai éclairé un tant soit peu vos lanternes
Accueil 
Calendrier
