| Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente |
| reference [2026/10/18 13:41] – [foreach in like] root | reference [2026/10/18 14:21] (Version actuelle) – [sub] root |
|---|
| La syntaxe est ⇒ ''call <identifiant>(params…)'' : appel d'un autre programme W de type //bibliothèque//, présent dans le répertoire des binaires WLIB car en p-code.\\ | La syntaxe est ⇒ ''call <identifiant>(params…)'' : appel d'un autre programme W de type //bibliothèque//, présent dans le répertoire des binaires WLIB car en p-code.\\ |
| Le passage des paramètres est facultatif et variable ; le contrôle est fait uniquement à l'exécution lors de l'utilisation des variables. Les paramètres en trop sont ignorés. Ceux manquant forceront la variable paramètre associée à l'état //non-déclarée//. 8 paramètres au maximum.\\ | Le passage des paramètres est facultatif et variable ; le contrôle est fait uniquement à l'exécution lors de l'utilisation des variables. Les paramètres en trop sont ignorés. Ceux manquant forceront la variable paramètre associée à l'état //non-déclarée//. 8 paramètres au maximum.\\ |
| Les paramètres sont obligatoirement des variables simples ou composées, passées par //référence// (PAS d'expression). Les variables chaînées avec indirection, de type ''var.var2!var3'' etc., sont interdites et provoqueront une erreur de compilation si utilisées comme paramètre. Les variables chaînées sans indirection, de type ''var1.var2.var3'' sont autorisées s'il n'y a pas de recouvrement : ''function(var1.var2, var1)'' provoquera une erreur de compilation, ''function(var1, var1)'' également, etc. De plus, il est possible de passer les paramètres en les nommant (comme avec [[#do|do]] et [[#invoke|invoke]]). | Les paramètres sont obligatoirement des variables simples ou composées, passées par //référence// (PAS d'expression). Les variables chaînées avec indirection, de type ''var.var2!var3'' etc., sont interdites et provoqueront une erreur de compilation si utilisées comme paramètre. Les variables chaînées sans indirection, de type ''var1.var2.var3'' sont autorisées s'il n'y a pas de recouvrement : ''function(var1.var2, var1)'' provoquera une erreur de compilation, ''function(var1, var1)'' également, etc. De plus, il est possible de passer les paramètres en les nommant (comme avec [[#do|do]] et [[#invoke|invoke]]). Enfin, en l'absence de paramètres, les parenthèses ''()'' peuvent être omises. |
| |
| <code wlang> | <code wlang> |
| Cette instruction permet d'appeler un sous-programme interne au source en cours. La subroutine doit être déclarée au préalable, sous peine de générer une exception.\\ | Cette instruction permet d'appeler un sous-programme interne au source en cours. La subroutine doit être déclarée au préalable, sous peine de générer une exception.\\ |
| La syntaxe est ⇒ ''do <var>(params…)'' : appel d'un sous-programme ''sub'' déjà déclaré dans le programme en cours (ou d'une méthode de classe/objet).\\ | La syntaxe est ⇒ ''do <var>(params…)'' : appel d'un sous-programme ''sub'' déjà déclaré dans le programme en cours (ou d'une méthode de classe/objet).\\ |
| Le passage des paramètres est facultatif et variable ; le contrôle est fait uniquement à l'exécution lors de l'utilisation des variables. Les paramètres en trop sont ignorés. Ceux manquant forceront la variable paramètre associée à l'état //non-déclarée//. 8 paramètres au maximum.\\ | Le passage des paramètres est facultatif et variable ; le contrôle est fait uniquement à l'exécution lors de l'utilisation des variables. Les paramètres en trop sont ignorés. Ceux manquant forceront la variable paramètre associée à l'état //non-déclarée//. 8 paramètres au maximum. Enfin, en l'absence de paramètres, les parenthèses ''()'' peuvent être omises.\\ |
| Les paramètres sont obligatoirement des variables simples ou composées, passées par //référence// (PAS d'expression). Les variables chaînées avec indirection, de type ''var.var2!var3'' etc., sont interdites et provoqueront une erreur de compilation si utilisées comme paramètre. Les variables chaînées sans indirection, de type ''var1.var2.var3'' sont autorisées s'il n'y a pas de recouvrement : ''function(var1.var2, var1)'' provoquera une erreur de compilation, ''function(var1, var1)'' également, etc.\\ | Les paramètres sont obligatoirement des variables simples ou composées, passées par //référence// (PAS d'expression). Les variables chaînées avec indirection, de type ''var.var2!var3'' etc., sont interdites et provoqueront une erreur de compilation si utilisées comme paramètre. Les variables chaînées sans indirection, de type ''var1.var2.var3'' sont autorisées s'il n'y a pas de recouvrement : ''function(var1.var2, var1)'' provoquera une erreur de compilation, ''function(var1, var1)'' également, etc.\\ |
| Il est possible de nommer les paramètres utilisés (comme dans [[#invoke|invoke]] et [[#call|call]]), ce qui permet de les passer dans n'importe quel ordre. Mais dans ce cas, tous les paramètres doivent être passés nommés (soit tous soit aucun et dans ce cas c'est l'ordre de la définition de la //sub// qui est pris en compte). La syntaxe est ''parametrenomme = p'', ''p'' étant la variable passée et ''parametrenomme'' son nom dans la définition. | Il est possible de nommer les paramètres utilisés (comme dans [[#invoke|invoke]] et [[#call|call]]), ce qui permet de les passer dans n'importe quel ordre. Mais dans ce cas, tous les paramètres doivent être passés nommés (soit tous soit aucun et dans ce cas c'est l'ordre de la définition de la //sub// qui est pris en compte). La syntaxe est ''parametrenomme = p'', ''p'' étant la variable passée et ''parametrenomme'' son nom dans la définition. |
| Cette instruction permet d'appeler un sous-programme de type //module//. Ce sont des sous-programmes écrits en C, compilé et appelés ici sous forme de binaire de l'OS (.o sous Linux, .dll sous Windows).\\ | Cette instruction permet d'appeler un sous-programme de type //module//. Ce sont des sous-programmes écrits en C, compilé et appelés ici sous forme de binaire de l'OS (.o sous Linux, .dll sous Windows).\\ |
| La syntaxe est ⇒ ''invoke <module>&<fonction>(param1, ..., param8)'' : appel d'un module, plugins du langage, écrit en C. Le fichier <module>.o (ou <module>.dll) doit se trouver dans le répertoire des exécutables WBIN. Le passage des paramètres est facultatif et variable, avec un maximum de 8 paramètres ; le contrôle est fait uniquement à l'exécution lors de l'utilisation des variables. Les paramètres en trop sont ignorés. Ceux manquant forceront la variable paramètre associée à l'état //non-déclarée// sauf s'ils sont obligatoires dans le module.\\ | La syntaxe est ⇒ ''invoke <module>&<fonction>(param1, ..., param8)'' : appel d'un module, plugins du langage, écrit en C. Le fichier <module>.o (ou <module>.dll) doit se trouver dans le répertoire des exécutables WBIN. Le passage des paramètres est facultatif et variable, avec un maximum de 8 paramètres ; le contrôle est fait uniquement à l'exécution lors de l'utilisation des variables. Les paramètres en trop sont ignorés. Ceux manquant forceront la variable paramètre associée à l'état //non-déclarée// sauf s'ils sont obligatoires dans le module.\\ |
| Comme avec [[#do|do]] et [[#call|call]], Les paramètres sont obligatoirement des variables simples ou composées, passées par //référence// (PAS d'expression). Les variables chaînées avec indirection, de type ''var.var2!var3'' etc., sont interdites et provoqueront une erreur de compilation si utilisées comme paramètre. Les variables chaînées sans indirection, de type ''var1.var2.var3'' sont autorisées s'il n'y a pas de recouvrement : ''function(var1.var2, var1)'' provoquera une erreur de compilation, ''function(var1, var1)'' également, etc. De plus, il est possible de passer les paramètres en les nommant (comme avec [[#do|do]] et [[#call|call]]). | Comme avec [[#do|do]] et [[#call|call]], Les paramètres sont obligatoirement des variables simples ou composées, passées par //référence// (PAS d'expression). Les variables chaînées avec indirection, de type ''var.var2!var3'' etc., sont interdites et provoqueront une erreur de compilation si utilisées comme paramètre. Les variables chaînées sans indirection, de type ''var1.var2.var3'' sont autorisées s'il n'y a pas de recouvrement : ''function(var1.var2, var1)'' provoquera une erreur de compilation, ''function(var1, var1)'' également, etc. De plus, il est possible de passer les paramètres en les nommant (comme avec [[#do|do]] et [[#call|call]]). Enfin, en l'absence de paramètres, les parenthèses ''()'' peuvent être omises. |
| <code wlang> | <code wlang> |
| invoke math&racinecarre(nombre, resultat) | invoke math&racinecarre(nombre, resultat) |
| sub math.carre(x, ret) | sub math.carre(x, ret) |
| let ret = x * x | let ret = x * x |
| | except |
| | endsub |
| | ; |
| | sub trace ; si pas de parametre, () peuvent être omis |
| | echonl 'Trace de debug' |
| except | except |
| endsub | endsub |