| Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente |
| reference [2026/10/18 09:56] – [sortedsearch] root | reference [2026/10/18 14:21] (Version actuelle) – [sub] root |
|---|
| ==== call ==== | ==== call ==== |
| |
| Cette instruction permet d'appeler un sous-programme externe au source en cours, de type //bibliothèque//. C'est un binaire au format W (en p-code) en mode compilé, ou un source W en mode interprété, chargé à la volée lors de l'appel.\\ | Cette instruction permet d'appeler un sous-programme externe au source en cours, de type //bibliothèque//. C'est un binaire au format W (en p-code compilé), chargé à la volée lors de l'appel.\\ |
| La syntaxe est ⇒ ''call <identifiant>(params…)'' : appel d'un autre programme W de type //bibliothèque//, présent soit dans le répertoire des sources WSRC en mode interprété, soit celui des binaires WBIN en mode 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> |
| Techniquement, la classe est identique à une hashtable, avec des éléments interne nécessaire à sa bonne gestion.\\ | Techniquement, la classe est identique à une hashtable, avec des éléments interne nécessaire à sa bonne gestion.\\ |
| Une classe hérite obligatoirement d'une autre classe, et d'une seule. Une classe créée par le langage W, //Base//, est l'origine de toute classe et est la classe mère par défaut si besoin.\\ | Une classe hérite obligatoirement d'une autre classe, et d'une seule. Une classe créée par le langage W, //Base//, est l'origine de toute classe et est la classe mère par défaut si besoin.\\ |
| La syntaxe est : ''class <nom classe> = {<nom classe mere}''. Le nom de la classe est un [[#variables_nombres_et_chainessyntaxe|identifiant]] simple, et la classe est de portée globale.\\ | La syntaxe est : ''class <nom classe> = {<nom classe mere>}''. Le nom de la classe est un [[#variables_nombres_et_chainessyntaxe|identifiant]] simple, et la classe est de portée globale.\\ |
| Les membres et méthodes d'une classe se déclarent et s'accèdent de la même manière qu'avec une hashtable.\\ | Les membres et méthodes d'une classe se déclarent et s'accèdent de la même manière qu'avec une hashtable.\\ |
| L'appel direct de membres ou méthodes de classe est possible => cela correspond à un mode de fonctionnement //static//.\\ | L'appel direct de membres ou méthodes de classe est possible => cela correspond à un mode de fonctionnement //static//.\\ |
| let Figure.nombreCote = 0 | let Figure.nombreCote = 0 |
| |
| class Quadrilatère = {Figure} ; la classe "Quadrilatere" herite des membres de la classe mère | class Quadrilatere = {Figure} ; la classe "Quadrilatere" herite des membres de la classe mère |
| |
| class Rectangle = {Quadrilatere} | class Rectangle = {Quadrilatere} |
| let Rectangle.largeur = 8 | let Rectangle.largeur = 8 |
| sub Rectangle.Aire(aire) | sub Rectangle.Aire(aire) |
| aire = this.longueur * this.largeur | let aire = this.longueur * this.largeur |
| except | except |
| endsub | endsub |
| |
| class Carre = {Quadrilatere} | class Carre = {Rectangle} |
| let Carre.nombreCote = 4 ; tous les membres et méthodes sont publics et modifiables | let Carre.nombreCote = 4 ; tous les membres et méthodes sont publics et modifiables |
| |
| declare a, c | declare a, c |
| let c = new Carre | let c = new Carre |
| let a = c.Aire(a) | do c.Aire(a) |
| ; la méthode "Aire" n'est pas trouvée dans la classe Carre (classe de l'objet "c"), W va chercher une méthode du même nom dans les classes mères, | ; la méthode "Aire" n'est pas trouvée dans la classe Carre (classe de l'objet "c"), W va chercher une méthode du même nom dans les classes mères, |
| ; et va trouver celle de "Rectangle", et affecter 80 à "a" | ; et va trouver celle de "Rectangle", et affecter 80 à "a" |
| 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. |
| <code wlang> | <code wlang> |
| if dividende = 0 then | if dividende = 0 then |
| echonl "Division impossible" ; affichage si la variable "dividende" vaut 0 puis saute à "endif" | echonl "Division impossible" ; affichage si la variable "dividende" vaut 0, puis saute à "endif" |
| elseif dividende = 1 then | elseif dividende = 1 then |
| echonl "Pas de calcul nécessaire" ; affichage si la variable "dividende" ne vaut pas 0, mais s'il est égale à 1 puis saute à "endif" | echonl "Pas de calcul nécessaire" ; affichage si la variable "dividende" ne vaut pas 0, et si elle est égale à 1, puis saute à "endif" |
| else | else |
| echonl "Il faut faire un calcul pour trouver le résultat" ; affichage si la variable "dividende" ne vaut ni 0 ni 1 | echonl "Il faut faire un calcul pour trouver le résultat" ; affichage si la variable "dividende" ne vaut ni 0 ni 1 |
| Si l'exécuteur de traitement arrive à l'instruction //except// sans exception, le programme //saute// à l'instruction [[#endsub|endsub]] ou [[#end|end]], retourne à l'appelant, et se termine dans le cas du programme principal.\\ | Si l'exécuteur de traitement arrive à l'instruction //except// sans exception, le programme //saute// à l'instruction [[#endsub|endsub]] ou [[#end|end]], retourne à l'appelant, et se termine dans le cas du programme principal.\\ |
| Si une exception survient dans le bloc de traitement, due à une autre instruction ou [[#throw|throw]], le programme saute automatiquement à la première ligne qui suit //except//. Une exception qui survient dans le bloc exception fait réagir le programme de la même manière que l'instruction [[#throw|throw]] : le code de la nouvelle exception est pris en compte et le programme saute à l'instruction [[#endsub|endsub]] ou [[:w:instr:end|]]. L'exception //remonte// dans le programme appelant et le fait arriver dans son bloc exception, etc. Enfin, uniquement dans le bloc exception, l'instruction [[#catch|catch]] permet d'annuler l'exception, et de revenir à l'appelant sans erreur.\\ | Si une exception survient dans le bloc de traitement, due à une autre instruction ou [[#throw|throw]], le programme saute automatiquement à la première ligne qui suit //except//. Une exception qui survient dans le bloc exception fait réagir le programme de la même manière que l'instruction [[#throw|throw]] : le code de la nouvelle exception est pris en compte et le programme saute à l'instruction [[#endsub|endsub]] ou [[:w:instr:end|]]. L'exception //remonte// dans le programme appelant et le fait arriver dans son bloc exception, etc. Enfin, uniquement dans le bloc exception, l'instruction [[#catch|catch]] permet d'annuler l'exception, et de revenir à l'appelant sans erreur.\\ |
| Dans les bloc exceptions, la variable système [[#varsys|@except]] donne le numéro de l'exception en cours (de 1 à 16 777 215). Mais attention, lors du retour au shell appelant, le code attendu par le shell est sur 8 bits : le code retour envoyé risque ne pas être celui voulu. | Dans les blocs exceptions, la variable système [[#varsys|@except]] donne le numéro de l'exception en cours (de 1 à 16 777 215). Mais attention, lors du retour au shell appelant, le code attendu par le shell est sur 8 bits : le code retour envoyé risque ne pas être celui voulu. |
| |
| <code wlang> | <code wlang> |
| L'instruction n'accepte que des variables, qui doivent toutes avoir été déclarées au préalable. | L'instruction n'accepte que des variables, qui doivent toutes avoir été déclarées au préalable. |
| En mode //comptage//, ''<increment>'' est facultatif, et vaut implicitement 1 alors. De plus, le mot clé //like// n'est pas autorisé.\\ | En mode //comptage//, ''<increment>'' est facultatif, et vaut implicitement 1 alors. De plus, le mot clé //like// n'est pas autorisé.\\ |
| En mode boucle sur variable, une exception est générée si les variables utilisées ne sont pas aux types attendus. Lorsque la source est une //Hashtable//, l'élément retourné à chaque boucle est la clé de la hashtable (format //Dynamic//).\\ | En mode boucle sur variable, une exception est générée si les variables utilisées ne sont pas aux types attendus. Lorsque la source est une //Hashtable//, l'élément retourné à chaque boucle est la clé de la hashtable (format //Dynamic//). Lorsque la source est une //Dynamic//, l'élément retourné à chaque boucle est le champ suivant, en fonction du séparateur de champ courant (variable système //@currfm// et cf. instruction [[#setsep|setsep]]).\\ |
| **__A préciser__** avec les règles détaillées (conversion variable, arrivée à ''<fin>'' testée selon le signe de ''<increment>'', syntaxe du filtre ''<like>'', ...) | **__A préciser__** avec les règles détaillées (conversion variable, arrivée à ''<fin>'' testée selon le signe de ''<increment>'', syntaxe du filtre ''<like>'', ...) |
| <code wlang> | <code wlang> |
| echonl compteur ; affiche tous les nombres de 1 a 10 | echonl compteur ; affiche tous les nombres de 1 a 10 |
| endfor | endfor |
| ; avec une variable "Dynamic", la boucle se fait sur les champs et sous-champs trouvés, et renvoi une variable de type "Dynamic" | ; avec une variable "Dynamic", la boucle se fait sur les champs trouvés, et renvoi une variable de type "Dynamic" |
| declare fruit, liste, filtre | declare fruit, liste, filtre |
| let liste = "" ; préciser si cette initialisation est nécessaire | let liste = "" ; préciser si cette initialisation est nécessaire |
| echonl fruit ; affiche les fruits commençant par "po" : pomme et poire (2 affichages) | echonl fruit ; affiche les fruits commençant par "po" : pomme et poire (2 affichages) |
| endfor | endfor |
| ; avec une variable "Hashtable"", la boucle se fait sur les clés de la table | ; avec une variable "Hashtable", la boucle se fait sur les clés de la table |
| declare legume, panier, initiale | declare legume, panier, initiale |
| let panier = {} | let panier = {} |
| |
| ==== input ==== | ==== input ==== |
| Cette instruction permet de faire une saisie utilisateur au clavier, en lisant l'entrée standard. Elle est suivi d'une variable, qui sera mise au type Dynamic et contiendra les caractères saisis, hors retour-chariot final, validant la saisie.\\ | Cette instruction permet de faire une saisie utilisateur au clavier, en lisant l'entrée standard. Elle est suivie d'une variable, qui sera mise au type Dynamic et contiendra les caractères saisis, hors retour-chariot final, validant la saisie.\\ |
| Dans les programmes de type [[#background|background]], l'instruction n'a aucune action (la saisie n'est pas faite) et ne provoque pas d'exception ; équivalent dans ce cas à [[#nop|nop]]. | Dans les programmes de type [[#background|background]], l'instruction n'a aucune action (la saisie n'est pas faite) et ne provoque pas d'exception ; équivalent dans ce cas à [[#nop|nop]]. |
| <code wlang> | <code wlang> |
| 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) |
| let Figure.nombreCote = 0 | let Figure.nombreCote = 0 |
| |
| class Quadrilatère = {Figure} ; la classe "Quadrilatere" herite des membres de la classe mère | class Quadrilatere = {Figure} ; la classe "Quadrilatere" herite des membres de la classe mère |
| |
| class Rectangle = {Quadrilatere} | class Rectangle = {Quadrilatere} |
| let Rectangle.largeur = 8 | let Rectangle.largeur = 8 |
| sub Rectangle.Aire(aire) | sub Rectangle.Aire(aire) |
| aire = this.longueur * this.largeur | let aire = this.longueur * this.largeur |
| except | except |
| endsub | endsub |
| |
| class Carre = {Quadrilatere} | class Carre = {Rectangle} |
| let Carre.nombreCote = 4 ; tous les membres et méthodes sont publics et modifiables | let Carre.nombreCote = 4 ; tous les membres et méthodes sont publics et modifiables |
| |
| let c.longueur = 5 | let c.longueur = 5 |
| let c.largeur = 5 | let c.largeur = 5 |
| let a = c.Aire(a) | do c.Aire(a) |
| ; la méthode "Aire" n'est pas trouvée dans la classe Carre (classe de l'objet "c"), W va chercher une méthode du même nom dans les classes mères, | ; la méthode "Aire" n'est pas trouvée dans la classe Carre (classe de l'objet "c"), W va chercher une méthode du même nom dans les classes mères, |
| ; et va trouver celle de "Rectangle", et affecter 80 à "a" | ; et va trouver celle de "Rectangle", et affecter 25 à "a" |
| let c{1} = new Carre ; interdit => provoque une erreur de compilation | let c{1} = new Carre ; interdit => provoque une erreur de compilation |
| </code> | </code> |
| <code wlang> | <code wlang> |
| declare a,b,c,d | declare a,b,c,d |
| let a = b + c * d ; le calcul commence par "c * d" puis "d" est ajouté au résultat | let a = b + c * d ; le calcul commence par "c * d" puis "b" est ajouté au résultat |
| let a = (b + c) * d ; le calcul commence par "b + c" puis le résultat est multiplié par "d" | let a = (b + c) * d ; le calcul commence par "b + c" puis le résultat est multiplié par "d" |
| |
| let a = b = 1 or b = 0 and c + d % 2 = 0 | let a = b = 1 or b = 0 and c + d % 2 = 0 |
| ; autre syntaxe de la même expression pour montrer les priorités | ; autre syntaxe de la même expression pour montrer les priorités (le mélange or et and ici n'a pas de sens, il conviendrait de mettre des parenthèses dans un cas réel) |
| let a = ( (b = 1) or ((b = 0) and ((c + (d % 2)) = 0) ) ) | let a = ( (b = 1) or (b = 0) and ((c + (d % 2)) = 0) ) |
| ; a reçoit la valeur numérique associée à @true ou @false, selon le résultat de l'expression | ; a reçoit la valeur numérique associée à @true ou @false, selon le résultat de l'expression |
| ; lisible | ; lisible |
| ==== precision ==== | ==== precision ==== |
| Cette instruction définit le nombre de décimales pour [[#variables_nombres_et_chainessyntaxe|l'arrondi]] en fin d'expression, lors de l'affectation.\\ | Cette instruction définit le nombre de décimales pour [[#variables_nombres_et_chainessyntaxe|l'arrondi]] en fin d'expression, lors de l'affectation.\\ |
| Les valeurs possible sont 0 1 2 3 4 5, 5 étant la valeur par défaut. Toute autre valeur provoquera une exception. | Les valeurs possibles sont 0 1 2 3 4 5, 5 étant la valeur par défaut. Toute autre valeur provoquera une exception. |
| <code wlang> | <code wlang> |
| precision <nombre> ; nombre de 0 à 5 | precision <nombre> ; nombre de 0 à 5 |
| 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 |
| let Figure.nombreCote = 0 | let Figure.nombreCote = 0 |
| |
| class Quadrilatère = {Figure} ; la classe "Quadrilatere" herite des membres de la classe mère | class Quadrilatere = {Figure} ; la classe "Quadrilatere" herite des membres de la classe mère |
| |
| class Rectangle = {Quadrilatere} | class Rectangle = {Quadrilatere} |
| let Rectangle.largeur = 8 | let Rectangle.largeur = 8 |
| sub Rectangle.Aire(aire) | sub Rectangle.Aire(aire) |
| aire = this.longueur * this.largeur ; pour utiliser la variable de la classe/objet courant | let aire = this.longueur * this.largeur ; pour utiliser la variable de la classe/objet courant |
| except | except |
| endsub | endsub |
| |
| class Carre = {Quadrilatere} | class Carre = {Rectangle} |
| let Carre.nombreCote = 4 ; tous les membres et méthodes sont publics et modifiables | let Carre.nombreCote = 4 ; tous les membres et méthodes sont publics et modifiables |
| |
| let c.longueur = 5 | let c.longueur = 5 |
| let c.largeur = 5 | let c.largeur = 5 |
| let a = c.Aire(a) | do c.Aire(a) |
| ; la méthode "Aire" n'est pas trouvée dans la classe Carre (classe de l'objet "c"), W va chercher une méthode du même nom dans les classes mères, | ; la méthode "Aire" n'est pas trouvée dans la classe Carre (classe de l'objet "c"), W va chercher une méthode du même nom dans les classes mères, |
| ; et va trouver celle de "Rectangle", et affecter 80 à "a" | ; et va trouver celle de "Rectangle", et affecter 25 à "a" |
| |
| let a = c.parent.Aire(a) ; fonctionnement identique a ci-dessous, car pas de méthode "Aire" dans la classe Carre | do c.parent.Aire(a) ; fonctionnement identique a ci-dessus, car pas de méthode "Aire" dans la classe Carre |
| |
| let a = c.this.Aire(a) ; la variable "this" permet de forcer l'appel de la méthode de la classe Carre : comme elle n'est pas présente, il y a exception | do c.this.Aire(a) ; la variable "this" permet de forcer l'appel de la méthode de la classe Carre : comme elle n'est pas présente, il y a exception |
| </code> | </code> |
| \\ | \\ |
| * dans le bloc de traitement, un saut direct au début du bloc exception du programme/sous-programme | * dans le bloc de traitement, un saut direct au début du bloc exception du programme/sous-programme |
| * dans le bloc exception, le remplacement de l'exception originelle par celle indiquée à la suite, et le saut à la fin du programme/sous-programme pour un retour à l'appelant | * dans le bloc exception, le remplacement de l'exception originelle par celle indiquée à la suite, et le saut à la fin du programme/sous-programme pour un retour à l'appelant |
| Dans les bloc exception, la variable système [[#varsys|@except]] donne le numéro de l'exception en cours, modifié par l'instruction //throw//. | Dans les blocs exception, la variable système [[#varsys|@except]] donne le numéro de l'exception en cours, modifié par l'instruction //throw//. |
| <code wlang> | <code wlang> |
| throw 1000 | throw 1000 |
| Les noms des variables @xxx est sensible à la casse ; elles sont toutes en minuscule. | Les noms des variables @xxx est sensible à la casse ; elles sont toutes en minuscule. |
| ^ Nom ^ Libellé ^ Numéro pour instruction [[referencepcode|PSHA]] ^ | ^ Nom ^ Libellé ^ Numéro pour instruction [[referencepcode|PSHA]] ^ |
| | @varnull| Code du type de variable Null, retour de [[#typeof|typeof()]] => 1 | 1 | | | @varnull| Code du type de variable Null, retour de [[#typeof|typeof]] => 1 | 1 | |
| | @varnumber| Code du type de variable Number, retour de [[#typeof|typeof()]] => 2 | 2 | | | @varnumber| Code du type de variable Number, retour de [[#typeof|typeof]] => 2 | 2 | |
| | @vardynamic | Code du type de variable Dynamic, retour de [[#typeof|typeof()]] => 5 | 5 | | | @vardynamic | Code du type de variable Dynamic, retour de [[#typeof|typeof]] => 5 | 5 | |
| | @varhashtable| Code du type de variable Hashtable, retour de [[#typeof|typeof()]] => 6 | 6 | | | @varhashtable| Code du type de variable Hashtable, retour de [[#typeof|typeof]] => 6 | 6 | |
| | @varsubroutine| Code du type de variable Subroutine (sub et méthode de classes/objets), retour de [[#typeof|typeof()]] => 3 | 3 | | | @varsubroutine| Code du type de variable Subroutine (sub et méthode de classes/objets), retour de [[#typeof|typeof]] => 3 | 3 | |
| | @varparam| Code du type de variable //paramètre//, retour de [[#typeof|typeof()]] => 4 | __**A preciser**__ 4 | | | @varparam| Code du type de variable //paramètre//, retour de [[#typeof|typeof]] => 4 | __**A preciser**__ 4 | |
| | @varobjet| Code du type de variable classe/objet, retour de [[#typeof|typeof()]] => 7 | 7 | | | @varobjet| Code du type de variable classe/objet, retour de [[#typeof|typeof]] => 7 | 7 | |
| | @varbuffer| Code du type de variable buffer, réservé à un usage interne de W (piles...) => 8 | 8 | | | @varbuffer| Code du type de variable buffer, réservé à un usage interne de W (piles...) => 8 | 8 | |
| | @part| Valeur du tag de portion de code source en cours, 0 par défaut | 21 | | | @part| Valeur du tag de portion de code source en cours, 0 par défaut | 21 | |
| | @except| Code exception en cour, 0 = pas d'exception | 20 | | | @except| Code exception en cours, 0 = pas d'exception | 20 | |
| | @exceptline | N° de la ligne du source W où a eu lieue la dernière exception | 19 | | | @exceptline | N° de la ligne du source W où a eu lieu la dernière exception | 19 | |
| | @pi | Nombre Pi => 3.14159| 30 | | | @pi | Nombre Pi => 3.14159| 30 | |
| | @true | 1 (tout nombre différent de 0 sera évalué à @true) | 11 | | | @true | 1 (tout nombre différent de 0 sera évalué à @true) | 11 | |
| | @level| Donne le niveau d'imbrication des appels de //sub// et //library//. 1 dans le programme principal. | 12 | | | @level| Donne le niveau d'imbrication des appels de //sub// et //library//. 1 dans le programme principal. | 12 | |
| | @kill | @true quand un signal SIGTERM ou SIGINT a été reçu, @false sinon | 13 | | | @kill | @true quand un signal SIGTERM ou SIGINT a été reçu, @false sinon | 13 | |
| | @fork | Vaut 0 dans le process fils, sinon dans le process père donne le pid du process fils créé (**usage furtur**) | 14 | | | @fork | Vaut 0 dans le process fils, sinon dans le process père donne le pid du process fils créé (**usage futur**) | 14 | |
| | @line | N° de la ligne du source W en cours | 22 | | | @line | N° de la ligne du source W en cours | 22 | |
| | @file | Nom du fichier source en cours (sans le chemin) | **__TODO__** A préciser 28 | | | @file | Nom du fichier source en cours (sans le chemin) | **__TODO__** A préciser 28 | |
| Les identifiants/noms de variables sont composés de 1 à 24 caractères, dans la gamme A-Za-z0-9 ; le premier caractère étant uniquement A-Za-z.\\ | Les identifiants/noms de variables sont composés de 1 à 24 caractères, dans la gamme A-Za-z0-9 ; le premier caractère étant uniquement A-Za-z.\\ |
| Les nombres sont composés d'un éventuel signe négatif ''-'', de 1 à 13 chiffres pour la partie entière et de 0 à 5 décimales, avec le ''.'' comme signe décimal si au moins une décimale est présente.\\ | Les nombres sont composés d'un éventuel signe négatif ''-'', de 1 à 13 chiffres pour la partie entière et de 0 à 5 décimales, avec le ''.'' comme signe décimal si au moins une décimale est présente.\\ |
| Attention : le signe ''-'' unaire n'est pas défini dans les expressions W. Pour utiliser un nombre négatif, il convient d'utiliser la fonction ''neg()''.\\ | Attention : le signe ''-'' unaire n'est pas défini dans les expressions W. Pour avoir une valeur négative, il convient d'utiliser la fonction ''neg()'' (sauf pour les constantes numériques qui acceptent le signe ''-'').\\ |
| **__A préciser__** comment utiliser les paramètres régionaux\\ | **__A préciser__** comment utiliser les paramètres régionaux\\ |
| Lors des calculs, le résultat final, affecté à la variable, est arrondi à la précision courante, de 0 à 5 décimales, 5 étant la valeur par défaut. L'instruction [[#precision|precision]] permet de changer la précision. | Lors des calculs, le résultat final, affecté à la variable, est arrondi à la précision courante, de 0 à 5 décimales, 5 étant la valeur par défaut. L'instruction [[#precision|precision]] permet de changer la précision. |
| let nombre = 1/3 ; nombre vaut 0.33333 | let nombre = 1/3 ; nombre vaut 0.33333 |
| precision 2 | precision 2 |
| let nombre = 1/3 ; maintenant nombre vaut 0,33 | let nombre = 1/3 ; maintenant nombre vaut 0.33 |
| precision 0 | precision 0 |
| let nombre = 5/3 ; nombre vaut 2 (1.66666 arrondi avec aucune décimale) | let nombre = 5/3 ; nombre vaut 2 (1.66666 arrondi avec aucune décimale) |
| |
| let fonction = "responsable" | let fonction = "responsable" |
| let chainage = hash!fonction.nom ; dans la hashtable "hash", prend la hashtable "responsable" et renvoi le contenu de sa variable "nom" | let chainage = hash!fonction.nom ; dans la hashtable "hash", prend la hashtable "responsable" (indirection sur 'fonction') et renvoi le contenu de sa variable "nom" |
| </code> | </code> |
| Les variables de type //Dynamic// peuvent être utilisées avec 2 suffixes optionnels, permettant de récupérer ou mettre à jour une sous-partie de la variable.\\ | Les variables de type //Dynamic// peuvent être utilisées avec 2 suffixes optionnels, permettant de récupérer ou mettre à jour une sous-partie de la variable.\\ |
| <code wlang> | <code wlang> |
| declare v | declare v |
| let v = neg(6.2) ; renvoie -6 | let v = neg(6.2) ; renvoie -6.2 |
| let v = neg(-3.8) ; renvoie 3.8 | let v = neg(-3.8) ; renvoie 3.8 |
| let v = neg(0) ; renvoie 0 | let v = neg(0) ; renvoie 0 |
| let x = "123;A,B,C;4,5;ZZZ" | let x = "123;A,B,C;4,5;ZZZ" |
| let x = remove(x, 4) ; supprime le champ n° 4 de "x" => reste "123;A,B,C;4,5" | let x = remove(x, 4) ; supprime le champ n° 4 de "x" => reste "123;A,B,C;4,5" |
| let x = remove(x, 2, 1) ; supprime dans le champ n° 2 le sous-champ n° 1 et met le résultat dans "y" (=> "123;B,C;4,5"), "x" n'est pas affecté | let y = remove(x, 2, 1) ; supprime dans le champ n° 2 de "x" le sous-champ n° 1 et met le résultat dans "y" (=> "123;B,C;4,5"), "x" n'est pas affecté |
| </code> | </code> |
| \\ | \\ |
| ==== round ==== | ==== round ==== |
| Arrondit le 1er paramètre à l'entier le plus proche, sur le nombre de décimales donné en 2ème paramètre. Le 1er paramètre est automatiquement converti en numérique, en générant une exception si le contenu n'est pas numérique.\\ | Arrondit le 1er paramètre à l'entier/le nombre décimal le plus proche, selon le nombre de décimales donné en 2ème paramètre. Le 1er paramètre est automatiquement converti en numérique, en générant une exception si le contenu n'est pas numérique.\\ |
| Le 2ème paramètre, nombre de décimales, est optionnel. S'il est omis, c'est la valeur de la [[#precision|précision]] en cours qui est utilisée. | Le 2ème paramètre, nombre de décimales, est optionnel. S'il est omis, c'est la valeur de la [[#precision|précision]] en cours qui est utilisée. |
| <code wlang> | <code wlang> |
| declare v | declare v |
| let v = round(6.2, 0) ; renvoie 6 | let v = round(6.2, 0) ; renvoie 6 |
| let v = round(-3.856, 1) ; renvoie -4 | let v = round(-3.856, 1) ; renvoie -3.9 |
| </code> | </code> |
| \\ | \\ |
| \\ | \\ |
| ==== sortedsearch ==== | ==== sortedsearch ==== |
| Fonction similaire à //search// si ce n'est qu'elle ne renvoie jamais //non trouvé// (0). Dans le cas où l'élément n'est pas trouvé, la fonction renvoie la position, en négatif, dans le champ/sous-champ ou il faudrait insérer l'élément cherché, pour conserver les champs/sous-champs triés, soit en croissant avec le paramètre [[#varsys|@asc]] (qui est le comportement par défaut), soit décroissant avec [[#varsys|@desc]].\\ | Fonction similaire à //search// si ce n'est qu'elle ne renvoie jamais //non trouvé// (0). Dans le cas où l'élément n'est pas trouvé, la fonction renvoie la position, en négatif, dans le champ/sous-champ ou il faudrait insérer l'élément cherché, pour conserver les champs/sous-champs triés, soit en croissant avec le paramètre [[#varsys|@asc]], soit décroissant avec [[#varsys|@desc]] (l'indication du sens du tri est obligatoire).\\ |
| Cette fonction permet de créer des listes triées, au fur et à mesure.\\ | Cette fonction permet de créer des listes triées, au fur et à mesure.\\ |
| <code wlang> | <code wlang> |
| echonl pos ; renvoie 3 car la chaine "troisième" est trouvée, dans le champ numéro 3 | echonl pos ; renvoie 3 car la chaine "troisième" est trouvée, dans le champ numéro 3 |
| |
| let pos = sortedsearch(var, "quatrieme") | let pos = sortedsearch(var, "quatrieme", @asc) |
| echonl pos | echonl pos |
| ; renvoie -3 car la chaine "quatrieme" n'est pas trouvee, et doit être insérée | ; renvoie -3 car la chaine "quatrieme" n'est pas trouvee, et doit être insérée |