| Les deux révisions précédentes Révision précédente Prochaine révision | Révision précédente |
| reference [2026/04/03 12:23] – root | reference [2026/04/03 12:31] (Version actuelle) – [Variables systèmes] root |
|---|
| ==== except ==== | ==== except ==== |
| Cette instruction marque le début du bloc exception et la fin du bloc de traitement du programme ou d'un sous-programme.\\ | Cette instruction marque le début du bloc exception et la fin du bloc de traitement du programme ou d'un sous-programme.\\ |
| Si l'exécuteur de traitement arrive à l'instruction //except// sans exception, le programme //saute// à l'instruction [[w:instr:endsub|endsub]] ou [[w:instr: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 [[w:instr: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 [[w:instr:throw|throw]] : le code de la nouvelle exception est pris en compte et le programme saute à l'instruction [[w:instr:endsub|endsub]] ou [[w:instr:end|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 [[w:instr: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|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 [[reference#variables_systemes|@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 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. |
| <code wlang> | <code wlang> |
| begin test | begin test |
| Cette instruction permet de //boucler// sur le contenu d'une variable //Dynamic//,//Hashtable// ou de compter.\\ | Cette instruction permet de //boucler// sur le contenu d'une variable //Dynamic//,//Hashtable// ou de compter.\\ |
| La syntaxe est => ''foreach <variable> in <variable_source> ou <debut>,<fin>,<increment>'' optionnel ''like <variable_dynamic>''\\ | La syntaxe est => ''foreach <variable> in <variable_source> ou <debut>,<fin>,<increment>'' optionnel ''like <variable_dynamic>''\\ |
| Le mot clé //foreach// est suivi d'une variable, qui reçoit à chaque boucle/comptage la valeur suivante. Ensuite vient le mot clé //in// puis la source des éléments que l'on veut traiter un par un. Enfin l'instruction se termine par le mot clé facultatif //like// permettant d'ajouter un filtre lors de la récupération de la valeur suivante. Le programme continue jusqu'à la prochaine instruction [[w:instr:endfor|endfor]] : l'extraction de la valeur suivante est faite à ce moment là et le programme //saute// à la suite de la ligne contenant l'instruction //foreach// correspondante. S'il n'y a plus de valeurs à récupérer, le programme continue à la suite de //endfor//.\\ | Le mot clé //foreach// est suivi d'une variable, qui reçoit à chaque boucle/comptage la valeur suivante. Ensuite vient le mot clé //in// puis la source des éléments que l'on veut traiter un par un. Enfin l'instruction se termine par le mot clé facultatif //like// permettant d'ajouter un filtre lors de la récupération de la valeur suivante. Le programme continue jusqu'à la prochaine instruction [[#endfor|endfor]] : l'extraction de la valeur suivante est faite à ce moment là et le programme //saute// à la suite de la ligne contenant l'instruction //foreach// correspondante. S'il n'y a plus de valeurs à récupérer, le programme continue à la suite de //endfor//.\\ |
| 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é.\\ |
| ==== if then ==== | ==== if then ==== |
| Cette instruction de tester une condition et d'exécuter du code différent en fonction du résultat du test.\\ | Cette instruction de tester une condition et d'exécuter du code différent en fonction du résultat du test.\\ |
| Entre les mots clés //if// et //then// se trouve une [[w:instr:operator|expression]], qui est __complètement__ évaluée. Si le résultat est //vrai//, le programme continue à la ligne suivante ; dès que l'instruction [[w:instr:elseelseif|else elseif]] est rencontrée, le programme saute à la première instruction [[w:instr:endif|endif]]. Si le résultat est //faux//, le programme continue après la première instruction trouvée else/elseif/endif. | Entre les mots clés //if// et //then// se trouve une [[#operator|expression]], qui est __complètement__ évaluée. Si le résultat est //vrai//, le programme continue à la ligne suivante ; dès que l'instruction [[#elseelseif|else elseif]] est rencontrée, le programme saute à la première instruction [[#endif|endif]]. Si le résultat est //faux//, le programme continue après la première instruction trouvée else/elseif/endif. |
| <code wlang> | <code wlang> |
| if dividende = 0 then | if dividende = 0 then |
| ==== 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 suivi 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 [[w:instr:background|background]], l'instruction n'a aucune action (la saisie n'est pas faite) et ne provoque pas d'exception ; équivalent dans ce cas à [[w:instr: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> |
| input reponse | input reponse |
| La syntaxe est => ''invoke <module>&<fonction>(param1, param2, param3)'' : 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. | La syntaxe est => ''invoke <module>&<fonction>(param1, param2, param3)'' : 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 3 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//.\\ | Le passage des paramètres est facultatif et variable, avec un maximum de 3 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//.\\ |
| Comme avec [[w:instr:do|do]] et [[w:instr:call|call]], Les paramètres sont obligatoirement des variables simples ([[w:syntax|identifiant]]), passées par //référence// (PAS d'expression).\\ | Comme avec [[#do|do]] et [[#call|call]], Les paramètres sont obligatoirement des variables simples ([[#variables_nombres_et_chainessyntaxe|identifiant]]), passées par //référence// (PAS d'expression).\\ |
| **A préciser** les variables chaînées, de type var.var2!var3 etc., sont interdites et provoqueront une exception si utilisées comme paramètre. | **A préciser** les variables chaînées, de type var.var2!var3 etc., sont interdites et provoqueront une exception si utilisées comme paramètre. |
| <code wlang> | <code wlang> |
| ==== let ==== | ==== let ==== |
| Cette instruction permet de faire une affectation de variable. Elle est suivie d'une variable, qui doit être déclarée auparavant sous peine d'exception.\\ | Cette instruction permet de faire une affectation de variable. Elle est suivie d'une variable, qui doit être déclarée auparavant sous peine d'exception.\\ |
| La variable peut être composée (imbrication de hashtable) et suffixée pour extraction de champs/sous-chaine : cf. [[w:syntax|syntaxe des variables]].\\ | La variable peut être composée (imbrication de hashtable) et suffixée pour extraction de champs/sous-chaine : cf. [[#variables_nombres_et_chainessyntaxe|syntaxe des variables]].\\ |
| Ensuite, le signe ''='' doit apparaitre, suivi d'une [[w:instr:operator|expression]].\\ | Ensuite, le signe ''='' doit apparaitre, suivi d'une [[#operator|expression]].\\ |
| <code wlang> | <code wlang> |
| declare a,b,c,d | declare a,b,c,d |
| library ; si pas de parametre, () peuvent être omis | library ; si pas de parametre, () peuvent être omis |
| </code> | </code> |
| L'instruction identifie le programme comme un traitement appelable depuis un autre programme W. Un programme de ce type ne peut pas s'exécuter de lui même ; il doit forcément être appelé depuis un autre traitement, initialisé par [[w:instr:begin|begin]]/[[w:instr:background|background]] ou une autre [[w:instr:library|library]]. | L'instruction identifie le programme comme un traitement appelable depuis un autre programme W. Un programme de ce type ne peut pas s'exécuter de lui même ; il doit forcément être appelé depuis un autre traitement, initialisé par [[#begin|begin]]/[[#background|background]] ou une autre [[#library|library]]. |
| |
| ==== loop ==== | ==== loop ==== |
| Marque le début dans le code d'une boucle inconditionnelle.\\ | Marque le début dans le code d'une boucle inconditionnelle.\\ |
| Cette instruction ne fait rien, si ce n'est de marquer la ligne comme celle de reprise lors du bouclage par l'instruction [[w:instr:endloop|endloop]].\\ | Cette instruction ne fait rien, si ce n'est de marquer la ligne comme celle de reprise lors du bouclage par l'instruction [[#endloop|endloop]].\\ |
| A l'intérieur du bloc de code de la boucle, l'instruction [[w:instr:break|break]] permet d'en sortir, et l'instruction [[w:instr::continue|continue]] permet de forcer la reprise au début de la boucle.\\ | A l'intérieur du bloc de code de la boucle, l'instruction [[#break|break]] permet d'en sortir, et l'instruction [[#continue|continue]] permet de forcer la reprise au début de la boucle.\\ |
| <code wlang> | <code wlang> |
| loop | loop |
| |
| ==== part ==== | ==== part ==== |
| Cette instruction sert de //tag// pour le code source en cours. Elle est suivie d'un nombre compris entre 0 et 255. A la fin de l'instruction, le source porte le tag indiqué par le nombre, et ne changera pas jusqu'au prochain appel d'une instruction //part//. L'appel d'un module ou d'une bilbiothèque remet à 0 le tag du source, mais sa valeur est restaurée au retour de l'appel. La variable système [[w:instr:varsys|@part]] contient le tag en cours.\\ | Cette instruction sert de //tag// pour le code source en cours. Elle est suivie d'un nombre compris entre 0 et 255. A la fin de l'instruction, le source porte le tag indiqué par le nombre, et ne changera pas jusqu'au prochain appel d'une instruction //part//. L'appel d'un module ou d'une bilbiothèque remet à 0 le tag du source, mais sa valeur est restaurée au retour de l'appel. La variable système [[#varsys|@part]] contient le tag en cours.\\ |
| Elle permet également au debugger de mettre un point d'arrêt sur la ligne de l'instruction. | Elle permet également au debugger de mettre un point d'arrêt sur la ligne de l'instruction. |
| <code wlang> | <code wlang> |
| part 5 | part 5 |
| </code> | </code> |
| Le //tag// est surtout utile lors d'une exception : dans le bloc [[w:instr:except|except]], @part permet de connaître la portion de code où a eue lieu l'exception, sous réserve que des instructions //part// aient été mises dans le bloc de traitement. Par défaut, sa valeur est 0.\\ | Le //tag// est surtout utile lors d'une exception : dans le bloc [[#except|except]], @part permet de connaître la portion de code où a eue lieu l'exception, sous réserve que des instructions //part// aient été mises dans le bloc de traitement. Par défaut, sa valeur est 0.\\ |
| |
| ==== precision ==== | ==== precision ==== |
| Cette instruction définit le nombre de décimales pour [[w:syntax|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 possible sont 0 1 2 3 4 5, 5 étant la valeur par défaut. Toute autre valeur provoquera une exception. |
| <code wlang> | <code wlang> |
| |
| ==== return ==== | ==== return ==== |
| Cette instruction //saute// à la fin du bloc en cours (instruction [[w:instr:endsub|endsub]]), sans changer les conditions d'exception.\\ | Cette instruction //saute// à la fin du bloc en cours (instruction [[#endsub|endsub]]), sans changer les conditions d'exception.\\ |
| Utilisée dans le bloc principal, elle //saute// à l'instruction [[w:instr:end|end]] finale, provoquant le retour à l'appelant. Le code retour au shell appelant est positionné avec le numéro d'exception, sur 8 bits, et 0 si pas d'exception. | Utilisée dans le bloc principal, elle //saute// à l'instruction [[#end|end]] finale, provoquant le retour à l'appelant. Le code retour au shell appelant est positionné avec le numéro d'exception, sur 8 bits, et 0 si pas d'exception. |
| <code wlang> | <code wlang> |
| return | return |
| |
| ==== returnon ==== | ==== returnon ==== |
| Cette instruction, similaire à [[w:instr:return|return]], //saute// à la fin du bloc en cours (instruction [[w:instr:endsub|endsub]]) si l'expression qui suit le mot clé //returnon// est évaluée à //vrai//.\\ | Cette instruction, similaire à [[#return|return]], //saute// à la fin du bloc en cours (instruction [[#endsub|endsub]]) si l'expression qui suit le mot clé //returnon// est évaluée à //vrai//.\\ |
| Sinon, le programme continue à la ligne suivante.\\ | Sinon, le programme continue à la ligne suivante.\\ |
| Utilisée dans le bloc principal, elle //saute// à l'instruction [[w:instr:end|end]] finale, provoquant le retour à l'appelant. Le code retour au shell appelant est positionné avec le numéro d'exception, sur 8 bits, et 0 si pas d'exception. | Utilisée dans le bloc principal, elle //saute// à l'instruction [[#end|end]] finale, provoquant le retour à l'appelant. Le code retour au shell appelant est positionné avec le numéro d'exception, sur 8 bits, et 0 si pas d'exception. |
| <code wlang> | <code wlang> |
| returnon compteur = 10 | returnon compteur = 10 |
| Cette instruction déclare une méthode (ou subroutine). l'instruction //sub// est suivie d'une variable, qui contiendra l'adresse de la subroutine et qui permettra son appel. Elle peut avoir des paramètres, facultatifs, en nombre libre.\\ | Cette instruction déclare une méthode (ou subroutine). l'instruction //sub// est suivie d'une variable, qui contiendra l'adresse de la subroutine et qui permettra son appel. Elle peut avoir des paramètres, facultatifs, en nombre libre.\\ |
| Déclarée sans contexte, la portée des subroutine est globale. Mais déclarée dans une classe ou un objet, la subroutine devient une méthode de classe ou d'objet. Elle peut également être déclarée dans une hashtable.\\ | Déclarée sans contexte, la portée des subroutine est globale. Mais déclarée dans une classe ou un objet, la subroutine devient une méthode de classe ou d'objet. Elle peut également être déclarée dans une hashtable.\\ |
| Enfin, une subroutine peut être déclarée dans une [[w:instr:library|library]] et restera accessible après la sortie de la library, car l'exécuteur laisse en mémoire chaque bibliothèque appelée.\\ | Enfin, une subroutine peut être déclarée dans une [[#library|library]] et restera accessible après la sortie de la library, car l'exécuteur laisse en mémoire chaque bibliothèque appelée.\\ |
| Le bloc de traitement a une structure identique au bloc principal du programme : liste d'instructions, [[w:instr:except|except]], liste d'instructions et [[w:instr:endsub|endsub]] | Le bloc de traitement a une structure identique au bloc principal du programme : liste d'instructions, [[#except|except]], liste d'instructions et [[#endsub|endsub]] |
| <code wlang> | <code wlang> |
| sub Carre(nombre) | sub Carre(nombre) |
| * 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 [[w:instr:varsys|@except]] donne le numéro de l'exception en cours, modifié par l'instruction //throw//. | Dans les bloc 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 |
| ===== Variables systèmes ===== | ===== Variables systèmes ===== |
| Le langage W dispose de plusieurs variables dites systèmes, c'est à dire mises à jour automatiquement par l'exécuteur du langage. Ces variables sont en lecture seule et ne peuvent donc pas être mises à jour par programme.\\ | Le langage W dispose de plusieurs variables dites systèmes, c'est à dire mises à jour automatiquement par l'exécuteur du langage. Ces variables sont en lecture seule et ne peuvent donc pas être mises à jour par programme.\\ |
| Leur présence dans l'instruction [[w:instr:let|let]] à gauche du signe ''='' provoquera une erreur à la compilation.\\ | Leur présence dans l'instruction [[#let|let]] à gauche du signe ''='' provoquera une erreur à la compilation.\\ |
| 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 [[w:instrpcode|PSHA]] ^ | ^ Nom ^ Libellé ^ Numéro pour instruction [[referencepcode|PSHA]] ^ |
| | @varnull| Code du type de variable Null, retour de [[w:instr:function#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 [[w:instr:function#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 [[w:instr:function#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 [[w:instr:function#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 [[w:instr:function#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 [[w:instr:function#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 [[w:instr:function#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 | |
| | @endian | Endianess de l'architecture en cours d'exécution : 0 big-endian, 1 little-endian | 27 | | | @endian | Endianess de l'architecture en cours d'exécution : 0 big-endian, 1 little-endian | 27 | |
| | @os | Code de l'OS d'exécution du binaire : 10 Unix, 20 autre | 23 | | | @os | Code de l'OS d'exécution du binaire : 10 Unix, 20 autre | 23 | |
| | @number | Valeur de retour possible pour la fonction [[w:instr:function#type|type()]] => 2 | 40 | | | @number | Valeur de retour possible pour la fonction [[#type|type()]] => 2 | 40 | |
| | @dynamic | Valeur de retour possible pour la fonction [[w:instr:function#type|type()]] => 5 | 41 | | | @dynamic | Valeur de retour possible pour la fonction [[#type|type()]] => 5 | 41 | |
| | @empty | Valeur de retour possible pour la fonction [[w:instr:function#type|type()]] => 0 | 42 | | | @empty | Valeur de retour possible pour la fonction [[#type|type()]] => 0 | 42 | |
| | @trim | Paramètre pour la fonction [[w:instr:function#format|format()]] => 1 | 50 | | | @trim | Paramètre pour la fonction [[#format|format()]] => 1 | 50 | |
| | @left | Paramètre pour la fonction [[w:instr:function#format|format()]] => 2 | 51 | | | @left | Paramètre pour la fonction [[#format|format()]] => 2 | 51 | |
| | @right | Paramètre pour la fonction [[w:instr:function#format|format()]] => 3 | 52 | | | @right | Paramètre pour la fonction [[#format|format()]] => 3 | 52 | |
| | @center | Paramètre pour la fonction [[w:instr:function#format|format()]] => 4 | 53| | | @center | Paramètre pour la fonction [[#format|format()]] => 4 | 53| |
| | @surround | Paramètre pour la fonction [[w:instr:function#format|format()]] => 5 | 54 | | | @surround | Paramètre pour la fonction [[#format|format()]] => 5 | 54 | |
| | @asc | Paramètre pour la fonction [[w:instr::function#sortedsearch|sortedsearch]] => 1 | 55 | | | @asc | Paramètre pour la fonction [[#sortedsearch|sortedsearch]] => 1 | 55 | |
| | @desc | Paramètre pour la fonction [[w:instr::function#sortedsearch|sortedsearch]] => 2 | 56 | | | @desc | Paramètre pour la fonction [[#sortedsearch|sortedsearch]] => 2 | 56 | |
| | @fm | Caractère séparateur de champ, par défaut => ''"0xFE"'' | 31 | | | @fm | Caractère séparateur de champ, par défaut => ''"0xFE"'' | 31 | |
| | @vm | Caractère séparateur de sous-champ, par défaut => ''"0xFD"'' | 32 | | | @vm | Caractère séparateur de sous-champ, par défaut => ''"0xFD"'' | 32 | |
| | @svm | Caractère pouvant servir de séparateur complémentaire => ''"0xFC"'' | 33 | | | @svm | Caractère pouvant servir de séparateur complémentaire => ''"0xFC"'' | 33 | |
| | @tm | Caractère pouvant servir de séparateur complémentaire => ''"0xFB"'' | 34 | | | @tm | Caractère pouvant servir de séparateur complémentaire => ''"0xFB"'' | 34 | |
| | @currfm | Caractère séparateur de champ en cours (modifiable avec l'instruction [[w:instr:setsep|setsep]]) | 35 | | | @currfm | Caractère séparateur de champ en cours (modifiable avec l'instruction [[#setsep|setsep]]) | 35 | |
| | @currvm | Caractère séparateur de sous-champ en cours (modifiable avec l'instruction [[w:instr:setsep|setsep]]) | 36 | | | @currvm | Caractère séparateur de sous-champ en cours (modifiable avec l'instruction [[#setsep|setsep]]) | 36 | |
| | @cr | Caractère retour chariot, utilisé pour les saut de lignes Windows en complément de @lf (ascii 13) | 37 | | | @cr | Caractère retour chariot, utilisé pour les saut de lignes Windows en complément de @lf (ascii 13) | 37 | |
| | @lf | Caractère saut de ligne (ascii 10) | 38 | | | @lf | Caractère saut de ligne (ascii 10) | 38 | |
| 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 utiliser un nombre négatif, il convient d'utiliser la fonction ''neg()''.\\ |
| **__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 [[w:instr: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. |
| Les chaines de caractères sont entourées soit par des quotes ''''' soit des double-quotes ''"''. A l'intérieur, un caractère peut être mis avec son code hexadécimal selon la forme ''#FF'' FF étant la valeur hexa du code, en majuscule (gamme 0-9A-F).\\ | Les chaines de caractères sont entourées soit par des quotes ''''' soit des double-quotes ''"''. A l'intérieur, un caractère peut être mis avec son code hexadécimal selon la forme ''#FF'' FF étant la valeur hexa du code, en majuscule (gamme 0-9A-F).\\ |
| **__A préciser__** avec la prise en charge d'UTF8\\ | **__A préciser__** avec la prise en charge d'UTF8\\ |
| |
| ===== Fonctions ===== | ===== Fonctions ===== |
| Dans les expressions, utilisées lors des [[w:instr:let|affectations]] de variable et des tests ([[w:instr:ifthen|if then]]), un certain nombre de fonctions sont disponibles. | Dans les expressions, utilisées lors des [[#let|affectations]] de variable et des tests ([[#ifthen|if then]]), un certain nombre de fonctions sont disponibles. |
| ==== abs ==== | ==== abs ==== |
| Renvoie la valeur absolue de son paramètre. Le paramètre est automatiquement converti en numérique, en générant une exception si le contenu n'est pas numérique. | Renvoie la valeur absolue de son paramètre. Le paramètre est automatiquement converti en numérique, en générant une exception si le contenu n'est pas numérique. |
| </code> | </code> |
| ==== format ==== | ==== format ==== |
| Formate la valeur passée en 1er paramètre, selon le [[w:instr:varsys|format]] donné en 2ème paramètre. D'éventuels 3ème et 4ème paramètres sont à passer selon le format demandé.\\ | Formate la valeur passée en 1er paramètre, selon le [[#varsys|format]] donné en 2ème paramètre. D'éventuels 3ème et 4ème paramètres sont à passer selon le format demandé.\\ |
| Si l'expression ne peut pas être convertie au format chaine (//Dynamic//), ou si un des paramètres attendus n'est pas au bon type, une exception est générée.\\ | Si l'expression ne peut pas être convertie au format chaine (//Dynamic//), ou si un des paramètres attendus n'est pas au bon type, une exception est générée.\\ |
| Lorsqu'un caractère est attendu, c'est le premier qui est pris en compte si une chaine trop longue est donnée.\\ | Lorsqu'un caractère est attendu, c'est le premier qui est pris en compte si une chaine trop longue est donnée.\\ |
| ==== not ==== | ==== not ==== |
| Renvoie le booléen contraire du paramètre. Le paramètre est automatiquement converti en numérique, en générant une exception si le contenu n'est pas numérique.\\ | Renvoie le booléen contraire du paramètre. Le paramètre est automatiquement converti en numérique, en générant une exception si le contenu n'est pas numérique.\\ |
| En W, le booléen [[w:instr:varsys|@false]] vaut 0 et le booléen [[w:instr:varsys|@true]] vaut 1 (tout nombre différent de 0 est évalué à //vrai// dans les expressions). | En W, le booléen [[#varsys|@false]] vaut 0 et le booléen [[#varsys|@true]] vaut 1 (tout nombre différent de 0 est évalué à //vrai// dans les expressions). |
| <code wlang> | <code wlang> |
| declare v | declare v |
| ==== 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 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.\\ |
| Le 2ème paramètre, nombre de décimales, est optionnel. S'il est omis, c'est la valeur de la [[w:instr: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 |
| </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 [[w:instr:varsys|@asc]], soit décroissant avec [[w:instr: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]].\\ |
| 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> |
| ==== type ==== | ==== type ==== |
| Renvoie le type de l'expression en paramètre : | Renvoie le type de l'expression en paramètre : |
| * [[w:instr:varsys|@number]] si numérique | * [[#varsys|@number]] si numérique |
| * [[w:instr:varsys|@dynamic]] si chaine de caractère | * [[#varsys|@dynamic]] si chaine de caractère |
| * [[w:instr:varsys|@empty]] si valeur //vide// | * [[#varsys|@empty]] si valeur //vide// |
| <code wlang> | <code wlang> |
| declare v | declare v |
| </code> | </code> |
| ==== typeof ==== | ==== typeof ==== |
| Renvoie le type de la variable en paramètre (PAS d'une expression), valeurs [[w:instr:varsys|@varxxx]].\\ | Renvoie le type de la variable en paramètre (PAS d'une expression), valeurs [[#varsys|@varxxx]].\\ |
| Si la variable est une imbrication de hashtable, seule la dernière sera évaluée. | Si la variable est une imbrication de hashtable, seule la dernière sera évaluée. |
| <code wlang> | <code wlang> |