Chapitre
XI
Ce chapitre va vous proposer quelques exemples de
programmes concernant les manipulations de base de la VAT. Malheureusement, il
est dur de trouver des exemples correspondant à ce type de programmes, car le
meilleur exemple qui soit pour ce chapitre serait un Explorer.
Avant de s'attaquer directement à notre exemple, il va
falloir que je vous explique une fonctionnalité de TIGCC, que je ne crois pas
avoir déjà expliqué. Il s'agit de la capacité que les programmes en C
ont à retourner une valeur à l'écran HOME de la TI au moment de quitter. Je
ne vais pas expliquer ici en détails comment cela fonctionne, mais je vais vous
demander d'admettre ce que je vais dire. (Je sais que cela ne correspond pas
vraiment à l'idée que l'on peut se faire d'un tutorial, mais ce n'est pas non
plus le but de Chapitre...).
Pour retourner une valeur à l'écran HOME, il faut
placer, au début du programme, avant la fonction _main,
l'instruction suivante :
#define RETURN_VALUE
Ainsi, le programme retournera la l'expression qui
sera placée au somment du Stack (pile utilisateur, si vous tenez à ce que je
donne un traduction approchée de ce terme.).
Ici, nous allons envoyer sur le top_estack
(Justement, il s'agit du sommet du Stack !) une liste constituée de chaînes de
caractères. Pour cela, il faut utiliser le code suivant :
push_END_TAG();
push_ANSI_string("chaine_de_caractères_3");
push_ANSI_string("chaine_de_caractères_2");
push_ANSI_string("chaine_de_caractères_1");
push_LIST_TAG();
Cela peut paraître étrange, mais il faut placer la
commande qui permet d'envoyer la fin de liste avant celle qui permet d'envoyer
le début de liste. Entre temps, il faut envoyer les éléments de la liste.
Pour cette raison, les éléments de la liste se trouveront en fait dans l'ordre
contraire à celui dans lequel vous les aurez envoyés.
A la fin de l'exécution du programme, vous verrez
apparaître, au lieu de "Done", une liste contenant les noms
des variables contenues dans la TI... mais en ordre inversé... (pour faire plus
simple, nous n'essayerons pas ici de les faire apparaître dans l'ordre
alphabétique, ce qui demanderait de retourner toute la liste.
Juste une petite précision (Zeljko Juric demande dans la
doc de TIGCC que celle-ci soit faite si on utilise la possibilité de retourner
des valeurs par un programme, comme le font les fonctions TI-BASIC) :
avec les ROM1.xx, aucun problème ne se pose, mais ce n'est malheureusement pas
le cas avec les ROM2.xx :
Sur les machines dotées de ce type de ROM, ce type de
fonction pourra être utilisée, et renverra de façon correcte son résultat à
l'écran HOME, mais vous ne pourrez pas utiliser ce type d'instructions TI-BASIC
:
fonction()->a
En effet, une "protection" du TIOS fait que
les programmes de type ASM ne peuvent pas être utilisés comme les
fonctions de type TI-BASIC... Heureusement, cette "protection"
peut être contournée par l'utilisation d'un programme résident. Le moyen de
contourner cette "protection" est déjà inclut dans DoorsOS et
UniversalOS, mais il ne l'est pas dans TeOS... Donc, si vous voulez pouvoir
utiliser une instruction comme celle qui est écrite juste au-dessus, il faut
que vous ayez DoorsOS ou UniversalOS installé sur votre TI... Cependant, cela
ne signifie pas que vous devez compiler vos programmes en mode Doors : le moyen
de contourner la "protection" fonctionne aussi avec les programmes
compilés en mode nostub.
Pour résumer, si vous utilisez une ROM2.xx sur votre TI,
vous devez avoir installé DoorsOS ou UniversalOS... une fois de plus !
A:
Obtenir la liste des répertoires présents sur la TI :
#define RETURN_VALUE
#include <tigcclib.h>
short _ti92plus,_ti89;
void _main(void)
{
SYM_ENTRY *SymPtr =
SymFindFirst(NULL, 4);
// Initialise la recherche : elle se fera dans
la partie de la VAT correspondant aux répertoires, uniquement...
push_END_TAG();
while(SymPtr)
// Boucle qui permet de chercher tant qu'il
reste des répertoires.
{
push_ANSI_string(SymPtr->name);
// envoi la chaîne de caractères
correspondants au nom sur le stack.
SymPtr =
SymFindNext();
}
push_LIST_TAG();
}
B:
Obtenir la liste des variables contenus dans le
répertoire dont le nom est placé en argument :
Pour cela, il vous faut utiliser le code suivant :
#define RETURN_VALUE
#include <tigcclib.h>
short _ti89, _ti92plus;
void _main(void)
{
ESI argptr = top_estack;
SYM_ENTRY *SymPtr =
SymFindFirst (GetSymstrArg argptr),
1);
if(ArgCount()
!= 1)
{
push_ANSI_string("Il_faut_un_argument_!!!");
return;
}
push_END_TAG();
while(SymPtr)
{
push_ANSI_string(SymPtr->name);
SymPtr = SymFindNext();
}
push_LIST_TAG();
}
Ce programme va retourner sous forme d'une liste composée
de chaînes de caractères les noms des variables contenues dans le répertoire
dont le nom aura été placé en argument. Attention, le nom du répertoire dans
lequel le programme cherchera doit être placé entre guillemets, comme une
chaîne de caractères...
C:
Obtenir la liste des répertoires OU celle des
variables présents sur la TI :
Nous allons maintenant regrouper les deux programmes que
nous venons d'étudier, afin de n'en faire qu'un seul, qui soit capable de
renvoyer la liste des répertoires présents sur la TI si on ne lui passe aucun
argument, et, si on lui passe un argument, la liste des variables contenues dans
le répertoire correspondant à l'argument.
#define RETURN_VALUE
#include <tigcclib.h>
short _ti89, _ti92plus;
void _main(void)
{
ESI argptr = top_estack;
if(ArgCount()
== 1)
{
SYM_ENTRY *SymPtr =
SymFindFirst(GetSymstrArg(argptr),
1);
push_END_TAG();
while(SymPtr)
{
push_ANSI_string(SymPtr->name);
SymPtr = SymFindNext();
}
push_LIST_TAG();
return;
}
if(ArgCount()
!= 1)
{
SYM_ENTRY *SymPtr =
SymFindFirst(NULL,4);
push_END_TAG();
while(SymPtr)
{
push_ANSI_string(SymPtr->name);
SymPtr =
SymFindNext();
}
push_LIST_TAG();
return;
}
}
Ce programme renverra la liste des répertoires si on lui
donne un nombre d'arguments différent de 1 (que ce soit aucun, ou plus de 1),
et la liste des variables contenues dans la répertoire placé en argument si
tel est le cas...
Retour au menu général
Chapitre
XII
|