reference

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Les deux révisions précédentes Révision précédente
Prochaine révision		 Révision précédente
reference [2026/03/06 14:18] – [sortedsearch] rootreference [2026/04/03 12:31] (Version actuelle) – [Variables systèmes] root
Ligne 3: Ligne 3:
 ==== background ==== ==== background ====
 C'est la première instruction, hors commentaires, d'un programme W.\\ C'est la première instruction, hors commentaires, d'un programme W.\\
-Elle peut être suivie d'un [[w:syntax|identifiant]], optionnel, permettant d'identifier le programme. +Elle peut être suivie d'un [[#variables_nombres_et_chainessyntaxe|identifiant]], optionnel, permettant d'identifier le programme. 
-<code w>+<code wlang>
 background background
  
 background monProgramme background monProgramme
 </code> </code>
-L'instruction identifie le programme comme un //service// ; contrairement à un programme initialisé avec [[w:instr:begin|begin]], la main est rendue immédiatement à l'utilisateur et le programme s'exécute en tâche de fond.\\+L'instruction identifie le programme comme un //service// ; contrairement à un programme initialisé avec [[#begin|begin]], la main est rendue immédiatement à l'utilisateur et le programme s'exécute en tâche de fond.\\
 \\ \\
 ==== begin ==== ==== begin ====
 C'est la première instruction, hors commentaires, d'un programme W.\\ C'est la première instruction, hors commentaires, d'un programme W.\\
-Elle peut être suivie d'un [[w:syntax|identifiant]], optionnel, permettant d'identifier le programme. +Elle peut être suivie d'un [[#variables_nombres_et_chainessyntaxe|identifiant]], optionnel, permettant d'identifier le programme. 
-<code w>+<code wlang>
 begin begin
  
Ligne 22: Ligne 22:
 \\ \\
 ==== break ==== ==== break ====
-Cette instruction sort de la boucle en cours [[w:instr:loop|loop]] ou [[w:instr:foreach|foreach]], sans changer les conditions d'exception.\\ +Cette instruction sort de la boucle en cours [[#loop|loop]] ou [[#foreach|foreach]], sans changer les conditions d'exception.\\ 
-Elle fonctionne comme si le traitement //sautait// à l'instruction suivant la ligne de fin de la boucle en cours [[w:instr:endloop|endloop]] ou [[w:instr:endfor|endfor]]. +Elle fonctionne comme si le traitement //sautait// à l'instruction suivant la ligne de fin de la boucle en cours [[#endloop|endloop]] ou [[#endfor|endfor]]. 
-<code w>+<code wlang>
 loop loop
    input v    input v
Ligne 35: Ligne 35:
  
 ==== breakon ==== ==== breakon ====
-Comme l'instruction [[w:instr:break|break]], cette instruction sort de la boucle en cours [[w:instr:loop|loop]] ou [[w:instr:foreach|foreach]], mais uniquement si la condition qui suit est évaluée à //vrai//.\\ +Comme l'instruction [[#break|break]], cette instruction sort de la boucle en cours [[#loop|loop]] ou [[#foreach|foreach]], mais uniquement si la condition qui suit est évaluée à //vrai//.\\ 
-Elle fonctionne comme si le traitement //sautait// à l'instruction suivant la ligne de fin de la boucle en cours [[w:instr:endloop|endloop]] ou [[w:instr:endfor|endfor]]. +Elle fonctionne comme si le traitement //sautait// à l'instruction suivant la ligne de fin de la boucle en cours [[#endloop|endloop]] ou [[#endfor|endfor]]. 
-<code w>+<code wlang>
 loop loop
    input v    input v
Ligne 49: Ligne 49:
 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 soit dans le répertoire des sources WSRC en mode interprété, soit celui des binaires WBIN en mode 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//.\\ 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//.\\
-Les paramètres sont obligatoirement des variables simples ([[w:syntax|identifiant]] simple), passées par //référence// (PAS d'expression).\\+Les paramètres sont obligatoirement des variables simples ([[#variables_nombres_et_chainessyntaxe|identifiant]] simple), 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 w>+<code wlang>
 call calculerRacineCarre(nombre, resultat) call calculerRacineCarre(nombre, resultat)
 </code> </code>
Ligne 58: Ligne 58:
 Cette instruction n'est utilisable QUE dans le bloc exception des programmes et sous-programmes.\\ Cette instruction n'est utilisable QUE dans le bloc exception des programmes et sous-programmes.\\
 Elle permet d'annuler l'exception en cours et de revenir au programme appelant sans remonter l'erreur. Elle permet d'annuler l'exception en cours et de revenir au programme appelant sans remonter l'erreur.
-<code w>+<code wlang>
 catch catch
 </code> </code>
  
 ==== class ==== ==== class ====
-Cette instruction permet de créer une //classe// au sens de la programmation objet. Le nom de la classe n'a pas besoin d'être déclarrée par [[w:instr:declare|declare]].\\+Cette instruction permet de créer une //classe// au sens de la programmation objet. Le nom de la classe n'a pas besoin d'être déclarée par [[#declare|declare]].\\
 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 [[w:syntax|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//.\\
-<code w>+<code wlang>
 class Figure = {Base} class Figure = {Base}
 let Figure.nombreCote = 0 let Figure.nombreCote = 0
Ligne 94: Ligne 94:
  
 ==== continue ==== ==== continue ====
-Cette instruction fait revenir le programme au début de la boucle en cours [[w:instr:loop|loop]] ou [[w:instr:foreach|foreach]], sans changer les conditions d'exception.\\ +Cette instruction fait revenir le programme au début de la boucle en cours [[#loop|loop]] ou [[#foreach|foreach]], sans changer les conditions d'exception.\\ 
-Elle fonctionne comme si le traitement //arrivait// à l'instruction de fin de la boucle en cours [[w:instr:endloop|endloop]] ou [[w:instr:endfor|endfor]], ce qui provoque le retour au début de la boucle pour exécuter l'occurrence suivante. +Elle fonctionne comme si le traitement //arrivait// à l'instruction de fin de la boucle en cours [[#endloop|endloop]] ou [[#endfor|endfor]], ce qui provoque le retour au début de la boucle pour exécuter l'occurrence suivante. 
-<code w>+<code wlang>
 loop                    ; l'instruction continue fait revenir le programme à cette ligne loop                    ; l'instruction continue fait revenir le programme à cette ligne
    input v    input v
Ligne 110: Ligne 110:
  
 ==== continueon ==== ==== continueon ====
-Comme l'instruction [[w:instr:continue|continue]], cette instruction fait revenir le programme au début de la boucle en cours [[w:instr:loop|loop]] ou [[w:instr:foreach|foreach]], mais uniquement si la condition qui suit est évaluée à //vrai//.\\ +Comme l'instruction [[#continue|continue]], cette instruction fait revenir le programme au début de la boucle en cours [[#loop|loop]] ou [[#foreach|foreach]], mais uniquement si la condition qui suit est évaluée à //vrai//.\\ 
-Elle fonctionne comme si le traitement //arrivait// à l'instruction de fin de la boucle en cours [[w:instr:endloop|endloop]] ou [[w:instr:endfor|endfor]], ce qui provoque le retour au début de la boucle pour exécuter l'occurrence suivante. +Elle fonctionne comme si le traitement //arrivait// à l'instruction de fin de la boucle en cours [[#endloop|endloop]] ou [[#endfor|endfor]], ce qui provoque le retour au début de la boucle pour exécuter l'occurrence suivante. 
-<code w>+<code wlang>
 loop                    ; l'instruction continue fait revenir le programme à cette ligne loop                    ; l'instruction continue fait revenir le programme à cette ligne
    input v    input v
Ligne 131: Ligne 131:
 Les variables appartenant à une hash table ne se déclarent pas, sous peine de déclencher une exception.\\ Les variables appartenant à une hash table ne se déclarent pas, sous peine de déclencher une exception.\\
 Une variable utilisée avant d'être déclarée provoquera une exception (variable inconnue).\\ Une variable utilisée avant d'être déclarée provoquera une exception (variable inconnue).\\
-Rappel : les noms des variables ont une longueur de [[w:syntax|24 caractères maximum]]. +Rappel : les noms des variables ont une longueur de [[#variables_nombres_et_chainessyntaxe|24 caractères maximum]]. 
-<code w>+<code wlang>
 declare x, y declare x, y
 declare somme declare somme
Ligne 142: Ligne 142:
  
 ==== delet ==== ==== delet ====
-Cette instruction permet de dé-affecter une variable : son contenu est supprimé et la variable perd son type (état identique suite à l'instruction [[w:instr:declare|declare]]).\\+Cette instruction permet de dé-affecter une variable : son contenu est supprimé et la variable perd son type (état identique suite à l'instruction [[#declare|declare]]).\\
 Si la variable est composée, imbrication de hashtable, la dernière est supprimée de la hashtable.\\ Si la variable est composée, imbrication de hashtable, la dernière est supprimée de la hashtable.\\
-<code w>+<code wlang>
 declare a,b,c,d declare a,b,c,d
 let a = 0            ; nombre let a = 0            ; nombre
Ligne 158: Ligne 158:
 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//.\\ Les paramètres sont obligatoirement des variables simples ([[w:syntax|identifiant]] simple), passées par //référence// (PAS d'expression).\\+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//.\\ Les paramètres sont obligatoirement des variables simples ([[#variables_nombres_et_chainessyntaxe|identifiant]] simple), 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 w>+<code wlang>
 do complexe.calculer(operation, nombre1, nombre2) do complexe.calculer(operation, nombre1, nombre2)
 </code> </code>
 ==== echo ==== ==== echo ====
-Cette instruction permet d'afficher sur la sortie standard (la console) le contenu d'une [[w:instr:varsys|variable]] ou une chaine (PAS d'expression ici).\\ +Cette instruction permet d'afficher sur la sortie standard (la console) le contenu d'une [[#varsys|variable]] ou une chaine (PAS d'expression ici).\\ 
-Dans les programmes de type [[w:instr:background|background]], l'instruction n'a aucune action (il n'y a pas de console) 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 (il n'y a pas de console) et ne provoque pas d'exception ; équivalent dans ce cas à [[#nop|nop]]. 
-<code w>+<code wlang>
 echo "bonjour !" echo "bonjour !"
 </code> </code>
 ==== echonl ==== ==== echonl ====
-Cette instruction est similaire à [[w:instr:echo|echo]], si ce n'est qu'un retour à la ligne est automatiquement ajouté à la fin de la chaîne affichée dans la console.\\ +Cette instruction est similaire à [[#echo|echo]], si ce n'est qu'un retour à la ligne est automatiquement ajouté à la fin de la chaîne affichée dans la console.\\ 
-Dans les programmes de type [[w:instr:background|background]], l'instruction n'a aucune action (il n'y a pas de console) 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 (il n'y a pas de console) et ne provoque pas d'exception ; équivalent dans ce cas à [[#nop|nop]]. 
-<code w>+<code wlang>
 echonl "bonjour !"    ; retour à la ligne automatiquement ajouté en fin de chaine echonl "bonjour !"    ; retour à la ligne automatiquement ajouté en fin de chaine
 </code> </code>
  
 ==== else elseif ==== ==== else elseif ====
-A l'intérieur d'un bloc d'instructions commencé par [[w:instr:ifthen|if then]], l'instruction //else// marque le début du code qui sera exécuté quand la ou les conditions précédentes ont toutes été évaluées à //faux//.\\ +A l'intérieur d'un bloc d'instructions commencé par [[#ifthen|if then]], l'instruction //else// marque le début du code qui sera exécuté quand la ou les conditions précédentes ont toutes été évaluées à //faux//.\\ 
-L'instruction //elseif// est similaire à //else// si ce n'est qu'une nouvelle condition est complètement évaluée et testée, comme avec [[w:instr:ifthen|if]], condition qui se trouve à la suite de //elseif// jusqu'au mot clé //then//. Si le résultat est //vrai//, le programme continue à la ligne suivante ; dès que l'instruction else/elseif est rencontrée, le programme saute à la première instruction suivant [[w:instr:endif|endif]]. Si le résultat est //faux//, le programme continue après la première instruction trouvée else/elseif/endif. +L'instruction //elseif// est similaire à //else// si ce n'est qu'une nouvelle condition est complètement évaluée et testée, comme avec [[#ifthen|if]], condition qui se trouve à la suite de //elseif// jusqu'au mot clé //then//. Si le résultat est //vrai//, le programme continue à la ligne suivante ; dès que l'instruction else/elseif est rencontrée, le programme saute à la première instruction suivant [[#endif|endif]]. Si le résultat est //faux//, le programme continue après la première instruction trouvée else/elseif/endif. 
-<code w>+<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"
Ligne 194: Ligne 194:
 Dans le cas d'un programme autonome, toutes les variables sont libérées de la mémoire avant de rendre la main. Dans le cas d'une bibliothèque, seules les variables locales sont libérées, comme pour un sous-programme.\\ Attention, les éléments globaux comme les classes/sub sont conservés jusqu'à la fin du programme principal.\\ Dans le cas d'un programme autonome, toutes les variables sont libérées de la mémoire avant de rendre la main. Dans le cas d'une bibliothèque, seules les variables locales sont libérées, comme pour un sous-programme.\\ Attention, les éléments globaux comme les classes/sub sont conservés jusqu'à la fin du programme principal.\\
 La bibliothèque est chargée en mémoire au premier appel et reste en mémoire à la sortie : les appels suivants ne provoquent donc pas de chargement. Cela permet également d'utiliser pendant toute la vie du programme les classes et sub déclarées dans une library. La bibliothèque est chargée en mémoire au premier appel et reste en mémoire à la sortie : les appels suivants ne provoquent donc pas de chargement. Cela permet également d'utiliser pendant toute la vie du programme les classes et sub déclarées dans une library.
-<code w>+<code wlang>
 end end
 </code> </code>
  
 ==== endfor ==== ==== endfor ====
-Cette instruction marque la fin du bloc [[w:instr:foreach|for each]] correspondant : récupération de la valeur suivante et //saut// à la ligne qui suit l'instruction //foreach//. S'il n'y a plus de valeur à récupérer, le programme continue après //endfor//. +Cette instruction marque la fin du bloc [[#foreach|for each]] correspondant : récupération de la valeur suivante et //saut// à la ligne qui suit l'instruction //foreach//. S'il n'y a plus de valeur à récupérer, le programme continue après //endfor//. 
-<code w>+<code wlang>
 foreach compteur in debut,fin foreach compteur in debut,fin
    echonl compteur    echonl compteur
Ligne 207: Ligne 207:
  
 ==== endif ==== ==== endif ====
-Marque la fin d'un bloc d'instructions commencé par [[w:instr:ifthen|if then]], tous les chemins de code arrivent à cette instruction : quand une condition est //vrai//, le bloc de programme à suivre est exécuté jusqu'à la première instruction [[w:instr:elseelseif|else elseif]]. Puis le programme saute à endif. S'il n'en trouve pas, il s'arrête au prochain endif trouvé.\\ +Marque la fin d'un bloc d'instructions commencé par [[#ifthen|if then]], tous les chemins de code arrivent à cette instruction : quand une condition est //vrai//, le bloc de programme à suivre est exécuté jusqu'à la première instruction [[#elseelseif|else elseif]]. Puis le programme saute à endif. S'il n'en trouve pas, il s'arrête au prochain endif trouvé.\\ 
-<code w>+<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"
Ligne 220: Ligne 220:
  
 ==== endloop ==== ==== endloop ====
-Cette instruction permet de revenir au début de la boucle définie auparavant par l'instruction [[w:instr:loop|loop]].\\+Cette instruction permet de revenir au début de la boucle définie auparavant par l'instruction [[#loop|loop]].\\
 S'il n'y a pas de boucle en cours, une erreur de compilation est générée. S'il n'y a pas de boucle en cours, une erreur de compilation est générée.
-<code w>+<code wlang>
 loop loop
    echonl "Ceci est une boucle infinie"    echonl "Ceci est une boucle infinie"
Ligne 231: Ligne 231:
 Cette instruction marque la fin du sous-programme en cours.\\ Cette instruction marque la fin du sous-programme en cours.\\
 Les variables locales sont libérées. Attention, les éléments globaux comme les classes/subs sont conservés jusqu'à la fin du programme principal. Les sous-programmes déclarés localement sont utilisable globalement. Les variables locales sont libérées. Attention, les éléments globaux comme les classes/subs sont conservés jusqu'à la fin du programme principal. Les sous-programmes déclarés localement sont utilisable globalement.
-<code w>+<code wlang>
 endsub endsub
 </code> </code>
Ligne 237: Ligne 237:
 ==== 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 [[w:instr: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 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 w>+<code wlang>
 begin test begin test
    <instructions>    <instructions>
Ligne 251: Ligne 251:
 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é.\\
 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//).\\
 **__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 w>+<code wlang>
 declare compteur, debut, fin, increment declare compteur, debut, fin, increment
 let debut = 1 let debut = 1
Ligne 302: Ligne 302:
 ==== 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 w>+<code wlang>
 if dividende = 0 then if dividende = 0 then
    echonl "Division impossible"    ; affichage si la variable "dividende" vaut 0    echonl "Division impossible"    ; affichage si la variable "dividende" vaut 0
Ligne 311: Ligne 311:
 ==== include ==== ==== include ====
 Cette instruction insère un fichier source W à la position courante. Son contenu est exécuté comme s'il faisait partie du source global.\\ Cette instruction insère un fichier source W à la position courante. Son contenu est exécuté comme s'il faisait partie du source global.\\
-Le fichier est récupéré dans l'arborescence dont le répertoire de base est défini dans la variable d'environnement [[w:env|WSRC]].\\+Le fichier est récupéré dans l'arborescence dont le répertoire de base est défini dans la variable d'environnement [[install|WSRC]].\\
 Attention : le nom du fichier à inclure ne doit __pas__ contenir de chemin, sinon le fichier ne sera pas trouvé et une exception sera générée. Attention : le nom du fichier à inclure ne doit __pas__ contenir de chemin, sinon le fichier ne sera pas trouvé et une exception sera générée.
-<code w>+<code wlang>
 include 'fichier.w' include 'fichier.w'
 </code> </code>
Ligne 319: Ligne 319:
 ==== 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 w>+<code wlang>
 input reponse input reponse
 </code> </code>
Ligne 328: Ligne 328:
 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 w>+<code wlang>
 invoke math&racinecarre(nombre, resultat) invoke math&racinecarre(nombre, resultat)
 </code> </code>
Ligne 336: Ligne 336:
 ==== 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 w>+<code wlang>
 declare a,b,c,d declare a,b,c,d
 let a = 0            ; nombre let a = 0            ; nombre
Ligne 350: Ligne 350:
 C'est la première instruction, hors commentaires, d'un programme W.\\ C'est la première instruction, hors commentaires, d'un programme W.\\
 La bibliothèque peut avoir des paramètres, facultatifs, en nombre libre. La bibliothèque peut avoir des paramètres, facultatifs, en nombre libre.
-<code w>+<code wlang>
 library(entree, resultat) library(entree, resultat)
  
Ligne 357: Ligne 357:
 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 w>+<code wlang>
 loop loop
    echonl "ceci est une boucle sans fin"    echonl "ceci est une boucle sans fin"
Ligne 382: Ligne 382:
 Les membres et méthodes d'un objet s'accèdent de la même manière qu'avec une hashtable. Par contre, lors de l'appel d'une méthode (sub), les pseudo variables //this// et //parent// sont définies automatiquement par l'exécuteur W, permettant d'accéder aux membres de l'objet, au lieu d'une variable locale/globale.\\ Les membres et méthodes d'un objet s'accèdent de la même manière qu'avec une hashtable. Par contre, lors de l'appel d'une méthode (sub), les pseudo variables //this// et //parent// sont définies automatiquement par l'exécuteur W, permettant d'accéder aux membres de l'objet, au lieu d'une variable locale/globale.\\
  
-<code w>+<code wlang>
 class Figure = {Base} class Figure = {Base}
 let Figure.nombreCote = 0 let Figure.nombreCote = 0
Ligne 412: Ligne 412:
 Cette instruction ne fait rien. Elle permet de notifier qu'une portion de code ne nécessite aucun traitement.\\ Cette instruction ne fait rien. Elle permet de notifier qu'une portion de code ne nécessite aucun traitement.\\
 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 w>+<code wlang>
 nop nop
 </code> </code>
Ligne 425: Ligne 425:
 Les parenthèses ''( )'' permettent d'isoler une expression de l'opération en cours.\\ Les parenthèses ''( )'' permettent d'isoler une expression de l'opération en cours.\\
 Les opérations sont exécutées de la priorité la plus forte à la plus faible (//or// //and// en dernier, donc) Les opérations sont exécutées de la priorité la plus forte à la plus faible (//or// //and// en dernier, donc)
-<code w>+<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 "d" est ajouté au résultat
Ligne 439: Ligne 439:
  
 ==== 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 w>+<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 w>+<code wlang>
 precision <nombre>   ; nombre de 0 à 5 precision <nombre>   ; nombre de 0 à 5
 </code> </code>
  
 ==== 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 w>+<code wlang>
 return return
 </code> </code>
  
 ==== 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 w>+<code wlang>
 returnon compteur = 10 returnon compteur = 10
 </code> </code>
Ligne 473: Ligne 473:
 Si des chaînes sont passées, le premier caractère est pris en compte. Si un nombre est passé, il sera considéré comme le code ASCII du caractère (plage 0-255 sinon exception).\\ Si des chaînes sont passées, le premier caractère est pris en compte. Si un nombre est passé, il sera considéré comme le code ASCII du caractère (plage 0-255 sinon exception).\\
 **__TODO__** pas de caractère UTF8 multi-byte permis ici **__TODO__** pas de caractère UTF8 multi-byte permis ici
-<code w>+<code wlang>
 setsep 10, "|"        ; pour gérer des variables dont les champs sont des lignes et les sous-champs des valeurs séparées par | sur chaque ligne setsep 10, "|"        ; pour gérer des variables dont les champs sont des lignes et les sous-champs des valeurs séparées par | sur chaque ligne
  
Ligne 482: Ligne 482:
 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 w>+<code wlang>
 sub Carre(nombre) sub Carre(nombre)
    let nombre = nombre * nombre    let nombre = nombre * nombre
Ligne 509: Ligne 509:
 Ces 2 variables sont présentes dans tous les objets et classes. Elles permettent : Ces 2 variables sont présentes dans tous les objets et classes. Elles permettent :
   * ''this'' : de forcer l'accès aux membres de chaque objet/classe, et de ne pas faire la recherche dans les classes mères pour les méthodes non présentes dans l'objet/classe courant   * ''this'' : de forcer l'accès aux membres de chaque objet/classe, et de ne pas faire la recherche dans les classes mères pour les méthodes non présentes dans l'objet/classe courant
-  * ''parent'' : de forcer la recherche des méthodes non pas depuis l'objet/classe en cours mais depuis la classe mère, et de lire les membres depuis la classe mère+  * ''parent'' : de forcer la recherche des méthodes non pas depuis l'objet/classe en cours mais depuis la classe mère (pas pour les membres)
 Ces variables ne sont utilisables que depuis un objet ou une classe, sinon une exception est générée à l'exécution. Ces variables ne sont utilisables que depuis un objet ou une classe, sinon une exception est générée à l'exécution.
-<code w>+<code wlang>
 class Figure = {Base} class Figure = {Base}
 let Figure.nombreCote = 0 let Figure.nombreCote = 0
Ligne 545: Ligne 545:
   * 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 w>+<code wlang>
 throw 1000 throw 1000
 </code> </code>
Ligne 552: Ligne 552:
 ===== 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 |
Ligne 580: Ligne 580:
 | @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 | 
 +| @lf | Caractère saut de ligne (ascii 10) | 38 | 
 +| @tab | Caractère //tabulation// (ascii 9) | 39 |
  
  
Ligne 603: Ligne 606:
 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\\
-<code w>+<code wlang>
 declare variable, nombre declare variable, nombre
 let variable = "abc" let variable = "abc"
Ligne 626: Ligne 629:
 Il est possible de faire un accès indirect en remplaçant ''.'' par ''!'' => dans ce cas, l'identifiant qui suit doit correspondre à une variable locale ou globale, et être de type //dynamic// : le contenu sera utilisé comme le nom de la variable à chercher dans la hashtable.\\ Il est possible de faire un accès indirect en remplaçant ''.'' par ''!'' => dans ce cas, l'identifiant qui suit doit correspondre à une variable locale ou globale, et être de type //dynamic// : le contenu sera utilisé comme le nom de la variable à chercher dans la hashtable.\\
 Le pseudo membre //count// permet de renvoyer le nombre d'éléments présents dans la hastable (géré automatiquement par W). Le pseudo membre //count// permet de renvoyer le nombre d'éléments présents dans la hastable (géré automatiquement par W).
-<code W>+<code wlang>
 declare hash, nom, carre, chainage, fonction, nb declare hash, nom, carre, chainage, fonction, nb
 let hash = {}   ; déclaration d'une hashtable let hash = {}   ; déclaration d'une hashtable
Ligne 647: Ligne 650:
     * ''[<expression>]'' extrait les <expression> derniers caractères de la variable     * ''[<expression>]'' extrait les <expression> derniers caractères de la variable
 Les 2 suffixes sont combinables, obligatoirement dans l'ordre ''{}[]'' Les 2 suffixes sont combinables, obligatoirement dans l'ordre ''{}[]''
-<code w>+<code wlang>
 declare d, e declare d, e
 let d = "champ1" let d = "champ1"
Ligne 661: Ligne 664:
  
 ===== 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 w>+<code wlang>
 declare v declare v
 let v = abs(-6)          ; renvoie 6 let v = abs(-6)          ; renvoie 6
Ligne 672: Ligne 675:
 ==== change ==== ==== change ====
 Remplace dans la variable source de type //Dynamic// une sous chaine par une autre. Remplace dans la variable source de type //Dynamic// une sous chaine par une autre.
-<code w>+<code wlang>
 declare v,w declare v,w
 let v = "20240101" let v = "20240101"
Ligne 681: Ligne 684:
 Renvoie le nombre d'occurrences, trouvées dans le premier paramètre, du caractère en deuxième paramètre.\\ Renvoie le nombre d'occurrences, trouvées dans le premier paramètre, du caractère en deuxième paramètre.\\
 A ne pas confondre avec la pseudo variable de hashtable //<hashvar>.count// A ne pas confondre avec la pseudo variable de hashtable //<hashvar>.count//
-<code w>+<code wlang>
 declare var, nb declare var, nb
 let var = "20240101" let var = "20240101"
Ligne 688: Ligne 691:
 ==== dcount ==== ==== dcount ====
 Renvoie le nombre de champs trouvés dans le premier paramètre. Le deuxième paramètre est optionnel et donne le n° du champ dans lequel la fonction compte alors les sous-champs.\\ Renvoie le nombre de champs trouvés dans le premier paramètre. Le deuxième paramètre est optionnel et donne le n° du champ dans lequel la fonction compte alors les sous-champs.\\
-<code w>+<code wlang>
 declare var, nb declare var, nb
 let var = "" let var = ""
Ligne 696: Ligne 699:
 let nb = dcount(var)      ; renvoie 3 car 3 champs sont présents dans "var" let nb = dcount(var)      ; renvoie 3 car 3 champs sont présents dans "var"
 let nb = dcount(var, 2)   ; renvoie 1 car il n'y a qu'un seul sous-champ dans le champ n° 2 ("deuxieme") let nb = dcount(var, 2)   ; renvoie 1 car il n'y a qu'un seul sous-champ dans le champ n° 2 ("deuxieme")
 +</code>
 +==== exp ====
 +Fonction de calcul de puissance entière. Elle renvoie le premier paramètre élevé à la puissance du deuxième paramètre. Si la puissance demandée est fractionnaire, une exception est générée. Les puissances négatives sont calculées (c'est l'inverse de la même puissance en positif). 
 +<code wlang>
 +;
 +echonl exp(2, 8)   ; affiche 256
 +echonl exp(@pi, 0) ; affiche 1
 +;
 </code> </code>
 ==== field ==== ==== field ====
 Extrait de la variable source un champ, en indiquant le caractère séparateur et le numéro du champ. Le quatrième paramètre est optionnel et permet de définir le nombre de champs consécutifs à extraire. Dans ce cas, la variable destinatrice, de type //Dynamic// sera au format multi-champs. Si absent, par défaut 1 seul champ est extrait. Fonctionnement identique à celui de la syntaxe var{x}, mais en pouvant choisir le séparateur et le nombre de champs à extraire.\\ Extrait de la variable source un champ, en indiquant le caractère séparateur et le numéro du champ. Le quatrième paramètre est optionnel et permet de définir le nombre de champs consécutifs à extraire. Dans ce cas, la variable destinatrice, de type //Dynamic// sera au format multi-champs. Si absent, par défaut 1 seul champ est extrait. Fonctionnement identique à celui de la syntaxe var{x}, mais en pouvant choisir le séparateur et le nombre de champs à extraire.\\
-<code w>+<code wlang>
 declare v,w declare v,w
 let v = "20240101" let v = "20240101"
Ligne 709: Ligne 720:
 </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.\\
 Pour //@trim// **__A préciser__** Pour //@trim// **__A préciser__**
-<code w>+<code wlang>
 declare i,j declare i,j
 let i = format(j, @trim)             ; supprimer les espaces en début, fin de chaine et n'en conserve qu'un à l'intérieur de la chaine s'il y en a plusieurs consécutifs let i = format(j, @trim)             ; supprimer les espaces en début, fin de chaine et n'en conserve qu'un à l'intérieur de la chaine s'il y en a plusieurs consécutifs
Ligne 723: Ligne 734:
 ==== frac ==== ==== frac ====
 Renvoie la partie fractionnaire 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 partie fractionnaire 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 w>+<code wlang>
 declare v declare v
 let v = frac(6.2)         ; renvoie 0.2 let v = frac(6.2)         ; renvoie 0.2
Ligne 732: Ligne 743:
 Renvoie la position d'une sous chaine dans la source. Le troisième paramètre, optionnel, permet de choisir l'occurrence de la sous chaine à chercher. Si absent, par défaut, la première est recherchée.\\ Renvoie la position d'une sous chaine dans la source. Le troisième paramètre, optionnel, permet de choisir l'occurrence de la sous chaine à chercher. Si absent, par défaut, la première est recherchée.\\
 Le comptage de la position commence à 1. La fonction renvoie 0 quand la sous chaine n'est pas trouvée, pour l'occurrence demandée. Le comptage de la position commence à 1. La fonction renvoie 0 quand la sous chaine n'est pas trouvée, pour l'occurrence demandée.
-<code w>+<code wlang>
 declare v, pos declare v, pos
 let v = "20240101" let v = "20240101"
Ligne 745: Ligne 756:
 Insère un champ/sous-champ à une variable //Dynamic//. Il y a deux syntaxes, une pour insérer un champ et une pour un sous-champ d'un champ.\\ Insère un champ/sous-champ à une variable //Dynamic//. Il y a deux syntaxes, une pour insérer un champ et une pour un sous-champ d'un champ.\\
 L'élément à insérer est de type //Number// ou //Dynamic//, sous peine d'exception. L'élément à insérer est de type //Number// ou //Dynamic//, sous peine d'exception.
-<code w>+<code wlang>
 declare v, w declare v, w
 let v = "" let v = ""
Ligne 753: Ligne 764:
 ==== int ==== ==== int ====
 Renvoie la partie entière 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 partie entière 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 w>+<code wlang>
 declare v declare v
 let v = int(6.2)         ; renvoie 6 let v = int(6.2)         ; renvoie 6
Ligne 761: Ligne 772:
 Renvoie la longueur de l'expression en paramètre. Le paramètre peut être soit numérique, soit une chaine (type //Dynamic//). Tout autre type de variable génère une exception.\\ Renvoie la longueur de l'expression en paramètre. Le paramètre peut être soit numérique, soit une chaine (type //Dynamic//). Tout autre type de variable génère une exception.\\
 **__A préciser__** avec l'utilisation d'UTF8 **__A préciser__** avec l'utilisation d'UTF8
-<code w>+<code wlang>
 declare v declare v
 let v = len(6.2)         ; renvoie 3 let v = len(6.2)         ; renvoie 3
Ligne 768: Ligne 779:
 ==== neg ==== ==== neg ====
 Renvoie l'opposé 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 l'opposé 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 w>+<code wlang>
 declare v declare v
 let v = neg(6.2)         ; renvoie -6 let v = neg(6.2)         ; renvoie -6
Ligne 776: Ligne 787:
 ==== 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 w>+<code wlang>
 declare v declare v
 let v = not(@true)       ; renvoie @false let v = not(@true)       ; renvoie @false
Ligne 785: Ligne 796:
 ==== remove ==== ==== remove ====
 Supprime un champ/sous-champ d'une variable //Dynamic//. Il y a deux syntaxes, une pour supprimer un champ et une pour un sous-champ d'un champ.\\ Supprime un champ/sous-champ d'une variable //Dynamic//. Il y a deux syntaxes, une pour supprimer un champ et une pour un sous-champ d'un champ.\\
-<code w>+<code wlang>
 declare x, y declare x, y
 setsep ';' , ',' setsep ';' , ','
Ligne 794: Ligne 805:
 ==== 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 w>+<code wlang>
 declare v declare v
 let v = round(6.2, 0)      ; renvoie 6 let v = round(6.2, 0)      ; renvoie 6
Ligne 803: Ligne 814:
 Renvoie la position d'un champ ou sous-champ dans la source. Avec 2 paramètres, la recherche s'effectue sur les champs de la source. Avec 3 paramètres, la recherche s'effectue sur les sous champs présents dans le champ dont le numéro est donnée par ce 3ème paramètre.\\ Renvoie la position d'un champ ou sous-champ dans la source. Avec 2 paramètres, la recherche s'effectue sur les champs de la source. Avec 3 paramètres, la recherche s'effectue sur les sous champs présents dans le champ dont le numéro est donnée par ce 3ème paramètre.\\
 Le comptage des champs et sous champs commence à 1. La fonction renvoie 0 quand la sous chaine n'est pas trouvée, dans aucun champ ni sous champ. Le comptage des champs et sous champs commence à 1. La fonction renvoie 0 quand la sous chaine n'est pas trouvée, dans aucun champ ni sous champ.
-<code w>+<code wlang>
 declare var, pos declare var, pos
 let var = "" let var = ""
Ligne 817: Ligne 828:
 </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 //@asc//, soit décroissant avec //@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 w>+<code wlang>
 declare var, pos declare var, pos
 let var = "" let var = ""
Ligne 833: Ligne 844:
 ; en champ n° 3 pour conserver la liste triée (entre "premier" et "troisieme") ; en champ n° 3 pour conserver la liste triée (entre "premier" et "troisieme")
 let var = insert(var, "quatrieme", abs(pos)) let var = insert(var, "quatrieme", abs(pos))
 +</code>
 +==== sqrt ====
 +Fonction de calcul de la racine carré de son paramètre. Si le paramètre est négatif, une exception est générée. 
 +<code wlang>
 +echonl sqrt(2)  ; affiche 1.41421
 </code> </code>
 ==== tonum ==== ==== tonum ====
 Force le type de l'expression au type @number, génère une exception si forçage impossible Force le type de l'expression au type @number, génère une exception si forçage impossible
-<code w>+<code wlang>
 declare v declare v
 let v = tonum("12") let v = tonum("12")
Ligne 842: Ligne 858:
 ==== tostring ==== ==== tostring ====
 Force le type de l'expression au type @dynamic, génère une exception si forçage impossible Force le type de l'expression au type @dynamic, génère une exception si forçage impossible
-<code w>+<code wlang>
 declare v declare v
 let v = tostring(@pi * 10) let v = tostring(@pi * 10)
Ligne 848: Ligne 864:
 ==== 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 w>+<code wlang>
 declare v declare v
 let v = type(1+2)         ; renvoie @number let v = type(1+2)         ; renvoie @number
Ligne 859: Ligne 875:
 </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 w>+<code wlang>
 declare w,x,y,z,a declare w,x,y,z,a
 let x = 12 let x = 12
-let w = typeof(x)  ; @varnumber+let w = typeof x  ; @varnumber
 let y = "ABC" let y = "ABC"
-let w = typeof(y)  ; @vardynamic+let w = typeof y  ; @vardynamic
 let z = {}  let z = {} 
-let w = typeof(z)  ; @varhashtable +let w = typeof z  ; @varhashtable 
-let w = typeof(a)  ; @varnull+let w = typeof a  ; @varnull
 </code> </code>
  
  
  • reference.1772806729.txt.gz
  • Dernière modification : 2026/03/06 14:18
  • de root