La manipulation de variables I

Ce chapitre et le suivant ont pour objectifs de vous présenter la manipulation de variables. Cette activité étant assez large j'ai décidé de séparer le domaine en deux parties bien distinctes : la manipulation de variables au niveau général (ce chapitre) et la manipulation de variables à un niveau plus "élémentaire" ("élémentaire" du point de vue machine mais pas du point de vue facilité :)) c'est à dire la manipulation des octets de variables.

Je ne peux continuer à expliquer le fonctionnement de Vertel3 sans que nous ne voyions une fonction que nous avons déjà utilisée mais qui nous est encore mystérieuse. Je veux bien sûr parler de "retr" vue au chapitre précédent.

Certaines fonctions de Vertel3 ont une variable de retour c'est à dire qu'elles renvoient des données fonctions des arguments passés. Nous avons vu précédemment que les fonctions "pict" et "pixl" peuvent, si le mode vaut -1, renvoyer des valeurs. Nous allons donc essayer de comprendre le mécanisme consistant à récupérer ces valeurs. Depuis le début de ce tutorial nous n'avons passé à Vertel3 que des arguments de type chaînes de caractère ou expressions. Même si pour vous les listes sont une autre sorte de variables elles n'en reste pas moins un ensemble de type de base que sont les chaînes de caractère ou les expressions. Pour ne pas déroger à la règle, Vertel3 ne renvoie que des expressions ou des chaînes de caractère. Il y a néanmoins une petite nuance : Vertel3 ne renvoie que des listes et ce même si il n'a qu'une seule valeur à renvoyer. Vertel3 renverra toujours un ensemble de type de base. Cela peut être pour vous un inconvénient puisqu'il faudra a chaque fois précisez le numéro de l'élément de l'ensemble en écrivant liste[numéro_de_l'élement] mais un réalité cela représente un avantage puisque qu'un élément peut être vide contrairement à une expression par exemple.

Soit l'instruction suivante (avec s une image de x=100 sur y=30) :

Vertel3 va alors analyser l'image s afin de voir ses dimensions en hauteur et largeur. La librairie enregistre ces valeurs dans une variable interne et par la fonction "retr" les renvoie dans la variable var. Comme nous l'avons mentionné plus haut, Vertel3 ne renvoie que des listes ainsi var sera de la forme : {100,30}. Il est ensuite simple de récupérer ces valeurs pour un calcul. Si, par exemple, on cherche le nombre de pixels de l'image il suffit de faire :

Note : Vous vous demandez peut-être pourquoi la fonction "pict" est suivie de 2 zéros puisque ce sont les arguments par défaut. Néanmoins rappelez vous qu'il faut que l'ordre entre arguments de même type soit respecté. L'appel suivant :

est donc considéré comme la demande de l'affichage de s en x=-1, y=0 et en mode=0.

Attention : Vertel3 est une librairie si puissante qu'elle en devient même dangereuse ! En effet si, par malheur, vous renvoyez des valeurs dans un nom de variable déjà existant, les valeurs d'origine seront intégralement supprimées et remplacées par la liste de sortie de Vertel3 et ce quelque soit le type d'origine ou son état (archivée ou pas).

Note : La propriété majeure de Vertel3 à l'égard des variables de retour est qu'elle ne renvoie qu'une seule et unique variable : ainsi si vous faites plusieurs appels de fonctions (qui renvoient des valeurs) avant la fonction "retr", la liste de sortie sera de la longueur du nombre d'arguments renvoyés. Prenons par exemple un appel totalement stupide :

Et imaginons que "fon1", "fon2", "fon3" et "fon4" renvoient chacune une expression : la variable var sera alors de la forme : {1,2,3} (où 1, 2 et 3 sont respectivement les valeurs de sortie de "fon1", "fon2" et "fon3". Vous remarquez bien évidemment que la "fon4" même si elle renvoie une valeur n'est pas prise en compte car sont appel est provoqué après la fonction "retr".

Au chapitre précédent, nous avons également fait la connaissance d'un symbole très pratique : le dièse (#). Son seul est unique but est d'empêcher le TIOS d'analyser une variable. Nous n'avons par contre qu'effleuré les conséquences d'un tel opérateur. Il est clair qu'il permet d'empêcher que le TIOS lise une liste (souvent longue) qu'on souhaite passer à Vertel3. Il existe néanmoins une autre conséquence majeure qui permet de résoudre un problème très facilement lorsqu'on connaît bien les méthodes d'analyse du TIOS. Imaginons une instruction de la forme :

Dans laquelle "fon1" est une fonction qui retourne une valeur (expression) et "fon3" fait une action qui dépend de la valeur retournée par "fon1". On peut croire que cette instruction sur Vertel3 fonctionnera correctement mais ce n'est pas le cas car le TIOS ne connaît pas var lors de son passage à "fon3". En effet après chaque appel de Vertel3, le TIOS regarde toutes les nouvelles variables crées. Il peut ainsi "savoir" si le programmeur utilise une variable existante ou une inexistante (il génèrera alors une erreur). Au "milieu" de l'appel de Vertel, il n'y a absolument aucune analyse du TIOS qui vérifie et comptabilise les nouvelles variables. Comme vous devez déjà trés bien le voir l'opérateur dièse va nous servir à éviter l'analyse du TIOS. Il suffit donc d'écrire :

Ainsi "#var" ne sera pas compris comme une variable mais comme une chaîne de caractère pour le TIOS et Vertel3 comprendra très bien que c'est la variable var qu'on souhaite utiliser.

Cette partie va vous énumérer toutes les fonctions de manipulation de variables dont vous disposez avec Vertel3. Toutes les explications de chaque fonction sont extraites de la documentation du réalisateur de Vertel3. J'ai néanmoins rajouté des notes afin de mieux comprendre certaines fonctions.

delt :: "var", type :: Cette fonction permet d'effacer la variable (programme, liste, expression, matrice, etc...) si le type est à zéro. Si le type est à 1, Vertel3 va chercher un dossier du nom de var et effacer l'ensemble de son contenu. Faites attention à cette fonction de Vertel3 : elle efface la totalité des données quelques soient leurs états (archivées, verrouillées ou cachée).

glue :: "group" [, "var"] :: Permet de regrouper plusieurs fichiers en un seul, de type "VTG". Ce fichier pourra être extrait pour récupérer son contenu. Si "var" est donnée, le groupe "group" est créé si il n'existait pas et "var" est ajoutée à l'intérieur. Ainsi, vous pouvez appeler :

pour ajouter plusieurs fichiers dans un groupe. Si "var" n'est pas indiquée, la fonction extrait tous les fichiers contenus dans le groupe sur la Ti. Si vous aviez groupé les fichiers en indiquant un nom de dossier. On ecrira, par exemple

Vertel essaiera de les placer dans ce dossier au lieu de les extraire dans le dossier courant. Si ce dossier n'existe pas, il sera demandé à l'utilisateur de le créer. Cette fonction est pratique surtout pour les maniaques puisqu'elle permet le rangement d'un tas de variables dans une seule autre. Malheureusement elle ne compresse pas les données.

hide :: "var", type, mode :: Permet de cacher ou non une variable "var" (si le type vaut 0) ou un dossier "var" (si le type vaut 1). Si le mode vaut 1 la variable sera cachée, si il vaut 0 elle sera rendue visible. Une variable cachée n'apparait plus dans l'écran Vars-Link d'AMS.

list :: [ "folder" ], mode, [ filter ] :: Cette fonction permet d'obtenir une liste des fichiers ou dossiers de la Ti. Si l'argument "folder" n'est pas donné, la fonction retourne la liste de tous les dossiers. En revanche si "folder" est le nom d'un dossier, elle retourne la liste des fichiers qu'il contient. L'argument "mode" sert alors, si il est fixé à 1, à retourner tous les noms de fichier préfixés du nom du dossier et de "\" (par exemple un fichier nommé "prog" dans le dossier "main" sera retourné "prog" si le mode vaut 0, ou "main\prog" si le mode vaut 1). Le filtre, facultatif, sert à filtrer les fichiers que doit retourner la fonction. Si il n'est pas donné, elle retournera tous les fichiers sans exeption; si il est fixé elle ne retournera que les fichiers de type correspondant (voir "Types de fichiers" pour plus d'informations). Si le filtre vaut par exemple 45, ce qui correspond aux variables de type "STR", la fonction ne retournera alors que les variables "STR" dans le dossier indiqué. Afin de mieux comprendre son utilisation, nous l'utiliserons dans le paragraphe suivant.

load :: {"var"/num} :: La fonction "load", seule, n'a pas beaucoup d'intérêt. Elle sert à charger une valeur (chaîne ou nombre) dans la liste de retour de Vertel, récupérable donc avec la fonction "retr". Ceci peut servir à compléter des résultats d'autres fonctions, mais a surtout d'autres utilités comme celle de pouvoir, en combinaison avec la fonction "locl", transmettre des variables locales d'un sous-programme à ses lanceurs (voir la fonction "locl").

size :: "var" :: Retourne la taille en octets de la variable "var".

stat :: "var", type :: Retourne l'état du dossier "var" ou de la variable "var" sous forme de 2 ou 3 bits. Pour rappel, savoir si le premier bit de la variable "bit" est armé ou non s'effectue avec le test "if (bit and 1)>0", pour le deuxième "if (bit and 2)>0" et pour le troisième "if (bit and 4)>0". Si type vaut 0, la fonction considère que "var" est une variable. Le premier bit est alors armé si la variable est cachée, le deuxième si elle est archivée, et le troisième si elle est verrouillée. Si type vaut 1, la fonction considère que "var" est un dossier. Le premier bit est alors armé si le dossier est caché, le second si il est fermé (dans le Vars-Link).

type :: "var" [, mode] :: Retourne le type de la variable "var" comme l'aurait fait la fonction "getType()" à quelques différences près : Elle permet de retourner le type d'une grande liste de fichiers grâce à la gestion de listes, peut connaître le type réel des fichiers "OTH", et retourne toujours le type en anglais, même si la calculatrice est dans une autre langue. Si le mode est à 1, Vertel renverra seulement "OTH" pour les variables de type personnalisé, comme le fait getType(), sinon elle indiquera la véritable extension. Les types existants sont : "NONE", "STR", "MAT", "LIST", "PRGM", "FUNC", "DATA", "GDB", "PIC", "TEXT", "ASM", "OTH" et "EXPR". Pour conserver la compatibilité avec getType(), la fonction renvoie "NONE" si la variable n'existe pas.

Note : Certaines fonctions concernant les variables n'ont pas été abordées ici. Ces fonctions sont : "strn" et "test". Ayant peu d'intérêt, nous ne les aborderons pas dans ce tutorial. Si néanmoins vous souhaitez en savoir plus sur ces fonctions, n'hésitez pas à lire la documentation officielle.

Afin de mieux maîtriser ces fonctions de manipulation de variable, nous allons faire un programme permettant de cacher les variables présentes sur votre calculatrice. Le programme affichera le nom, le chemin et l'état de la variable (cachée ou pas).

Ce programme montre tout d'abord qu'on ne peut pas utiliser seulement Vertel3 pour programmer. En effet, la majeure partie de ce code est composée de Ti-Basic. Analysons maintenant cette petite application en détail. On commence tout d'abord par initialiser les variables en local. Cela permettra de ne pas les "voir" lors du listage des variables par Vertel.

Vertel affiche tout d'abord "Chargement..." dans la Status Line et effectue ensuite le listage des dossier par la fonction "list". On retourne le résultat de ce listage dans la variable f puis on rappelle la fonction "list" sur cette variable f. Le TIOS ne connaissant pas la variable f (nous somme en cours d'appel de Vertel) , il faut utiliser le dièse. L'appel de la fonction "list" sur "#f" puis de "retr" aura pour effet de mettre l'intégralité des noms de variable dans la liste f.

On souhaite ensuite faire une copie de f dans f2. Pour réaliser cette action, on charge la liste f et on la retourne dans f2 en utilisant la fonction "load". On finit ensuite par vérifier l'état de chacune des variables en utilisant la fonction "stat". Le résultat est renvoyé dans la liste etat.

Nous arrivons maintenant dans la partie Ti-Basic que je vais expliquer rapidement puisque vous êtes sensé très bien connaître ce langage. La boucle for permet de concaténer la chaine " ▪" à la fin du nom de variable si cette dernière est cachée. On demande ensuite quelle variable doit être (dé)cachée à l'aide de PopUp.

Note : Le "If a>dim(etat)" permet de vérifier si l'utilisateur à appuyer sur [ESC]. Si c'est le cas, on ne fait rien.

Le programme exécute enfin l'appel de Vertel sur la variable choisie. le paramètre b sera à 0 si la variable était cachée (on souhaite la montrer) et à 1 si elle était apparente (on souhaite la cacher)

Note : Pour vérifier si la variable est cachée on utilise l'instruction "(etat[a] and 1)>0". En effet, si le premier bit est à armé (c'est à dire à 1) cela signifie que la variable est cachée. Le TIOS va donc faire un ET logique entre etat[a] et 1 (c'est à dire 0b001 en binaire). Afin de mieux comprendre prenons un exemple : soit l'état de la variable etat[a] égal à 7. En binaire, 7 s'écrit 0b111 donc la variable est archivée, lockée et cachée. Le ET logique de 0b111 avec 0b001 donnera : 0b001 c'est à dire 1 en décimal. étant supérieur à 0, on en déduit que la variable etat[a] était bien cachée.