Hello tout le monde ! Aujourd'hui on va se pencher (pas trop hein, faut pas tomber ) sur cet magnifique outil qui s'appelle la VAT

Citation :

Hello. C'est quoi la VAT ?

J'y viens. VAT est un acronyme pour Variable Allocation Table

Citation :

Euh...moi speak english pas très well...

Laisse-moi finir !
Il s'agit donc en français d'une table regroupant des données sur chaque variable présente sur la TI. Elle est constamment changeante lorsque vous modifiez des données, vous en créez ou vous en effacez.
Pour ceux qui sont déjà plus-que-familiers avec le PC, pour ne pas dire les geeks, on retrouve la VAT sous la forme de la FAT.

Citation :

Aaaah...

Bééééé
ok ok, je sors, z'aurez pas la suite du tuto :p
[/mode plaisanterie][mode prof]

Citation :

non.

Quoi non ? Bon ok.

[/mode prof][mode plaisanterie]

Allez, on va enfin commencer ce tuto.
Ce tuto se divisera en plusieurs chapitres. Tout d'abord, et c'est la "leçon" d'aujourd'hui, nous allons commencer par la base, c'est-à-dire accéder à une variable...


La TI est faite d'une multitude de variables, d'origines diverses, ce peut être des listes, des matrices, des programmes, des jeux, des anti-sèches (hum ) ou autre...mais la méthode pour accéder à une variable, quelque soit son type est toujours la même

Citation :

Oui, bon, c'est quoi cette méthode ?

La politesse, tu connais ? on interrompt pas un prof quand il parle ! Il faut lever la main d'abord
Bon, trève de plaisanteries, pour accéder à une variable il faut obtenir un pointeur vers cette variable. Pour ceux qui ne sont pas familiers avec les pointeurs, ce n'est pas trop grave pour l'instant, mais il faut quand même connaitre un peu les pointeurs pour plus tard

Il existe 2 types de pointeurs : les pointeurs de type SYM_ENTRY et de type HSym

Citation :

Pourquoi faire compliqué quand on peut faire simple...

Effectivement, pourquoi utiliser 2 pointeurs pour faire la même chose ?
Et bien, ces 2 pointeurs ne font pas exactement la même chose. Un type de pointeur sera préféré à l'autre pour faire telle manipulation car certaines fonctions nécessitent un pointeur HSym et d'autres un pointeur SYM_ENTRY

Il est possible de "convertir" un pointeur HSym en pointeur SYM_ENTRY grâce à la fonction DerefSym(pointeur HSym). Cela s'appelle "déréférencer un pointeur" (si vous ne comprenez pas ce terme, regardez un tuto sur les pointeurs ). L'inverse (SYM_ENTRY -> HSym) est plus difficile

Personnellement, je préfère utiliser des pointeurs SYM_ENTRY lorsque je manipule la VAT, mais je n'ai pas encore tout exploré. Il faut savoir adapter selon ce que l'on veut faire

Citation :

Compris :)

Bien. Passons alors à la suite :)
Regardons dans la doc ce qui constitue un pointeur SYM_ENTRY :

Code:

    typedef struct
    {
          char name[8];
          unsigned short compat;
          union
          {
                unsigned short flags_n;
                struct
                {
                      unsigned short busy:1, local:1, flag1_5:1, flag1_4:1,
                      collapsed:1, twin:1, archived:1, in_view:1;
                            unsigend short folder:1, overwritten:1, checked:1,                          hidden:1, locked:1, statvar:1, graph_ref_1:1,                                  graph_ref_0:1;
                }bits;
            }flags;
        HANDLE handle; 
    }_;

Compliqué, huh ?

Citation :

o_O Oui ! O_o

Rassurez-vous, pour la plupart des manipulations, seuls quelques éléments seront utiles :)

Maintenant qu'on a exploré les pointeurs, on va relier ça à notre sujet : comment accéder à une variable ?
Et bah, comme on l'a dit plus tôt, on va utiliser un pointeur HSym ou SYM_ENTRY vers notre variable

Citation :

cela donne donc

Code:

    SYM_ENTRY *sym;

...
et après ?

après, il faut trouver notre variable. Pour cela, on va utiliser une nouvelle fonction, la fonction SymFind()...
2 problèmes se posent alors :
D'abord, la fonction SymFind() retourne un HSym. Facile à résoudre, on utilisera ensuite l'instruction DerefSym() pour convertir en SYM_ENTRY
A noter qu'on peut également résoudre ce problème en utilisant la fonction SymFindPtr() qui retourne directement un pointeur de type SYM_ENTRY. Ainsi, ces 2 codes font exactement la même chose :

Code:

    SYM_ENTRY *sym;
    HSym hsym = SymFind($("test"));
    *sym = DerefSym(hsym);

Code:

    SYM_ENTRY *sym = SymFindPtr($("test"));

Le 2ème problème nécessite d'être plus développé : la fonction attend un argument de type SYM_STR

Citation :

Késako ?

Nan, on dit "qu'est-ce que c'est" !
Eh oui, peut-être que vous aviez pensé qu'en faisant SymFind("test") vous obtiendriez ce que vous voudriez avoir. En fait, ce n'est pas tout à fait ça
Les variables SYM_STR ont une structure bien précise, disons pour simplifier une version évoluée des chaines classiques.
Leur structure est bien particulière :

Code:

      \0nom_de_la_variable taille_du_nom_de_la_variable

Citation :

Euh...et j'vais devoir utiliser ça tout le temps ?

Non. Il existe ce qu'on appelle une "macro constructeur", qui, pour simplifier, se chargera directement de transformer une chaine au bon format. Elle s'utilise grâce au signe $, oui, le signe dollar (à quoi pensait donc le programmeur à ce moment ^^)

Ainsi, pour simplifier, on peut écrire directement SymFind($("test")) qui créera un pointeur HSym vers la variable "test" du répertoire courant.

Attention toutefois, il existe quelques exceptions dans lesquelles l'utilisation de la macro est impossible. Il faut alors le faire "à la main" en utilisant les instructions strcpy() et strlen()

Voilà. On sait maintenant comment utiliser la fonction SymFind(), il ne reste plus qu'à l'utiliser. Pour obtenir un pointeur SYM_ENTRY sur la variable main\test, il faudra donc utiliser le code suivant :

Code:

          HSym hsym;
        SYM_ENTRY sym;
        hsym=SymFind($(main\\test));    //attention, les "\\" sont importants !
        sym=DerefSym(hsym);

On peut condenser ce code en une ligne :

Code:

          SYM_ENTRY sym=DerefSym(SymFind($(main\\test)));

Citation :

Cool, j'ai tout compris :)

Bien. alors le tuto s'arrête là.









Aha ! vous y avez cru, hein ?
Il reste une dernière chose à mettre au point avant de terminer ce tuto : les dossiers. On sait maintenant comment accéder aux fichiers, mais pour les dossiers ?
Pas trop de différences, ce sera assez court.
Le principe reste le même, à la différence qu'au lieu d'utiliser SymFind(), on va utiliser la fonction SymFindHome()
Cette fonction prend un argument de type SYM_STR et retourne un pointeur de type HSym. Le reste est pareil.

Avant de clore ce 1er chapitre, précisons qu'en cas d'erreur, les fonctions SymFind() et SymFindHome() retournent NULL. Il faut donc tester que le pointeur a donc été bien crée.



Voilà, c'est tout pour aujourd'hui.
Prochain chapitre : on apprendra à obtenir la liste de tous les dossiers et de toutes les variables présents sur la TI et on apprendra à les manipuler
Un petit aperçu :

Code:

            SYM_ENTRY *sym=SymFindFirst(SYMSTR("main"),0);
               
                char name[];

            while(sym)
            {
                strcpy(name,sym->name);
                printf("%s",name);
                    ngetchx();
                sym = SymFindNext();
            }

Ce bout de code retournera les noms de toutes les variables présentes dans le répertoire main. On en saura plus au prochain tuto

J'ai (presque) tout compris sans posseder de 89, donc je crois pouvoir dire good job!

hmm ^^
qu'est-ce que tu n'as pas compris ?

Le dereferencement. Mais je suppose que c'est normal que je ne connaisse pas, puisque je n'ai jamais lu de tutos sur les pointeurs en C pour 68k.

bah c'est le simple fait d'attribuer une valeur à une variable via un pointeur

Code:

char *pointeur, variable;
pointeur=&variable;
*pointeur=255;                      // <= déréférencement

Ah ok.
C'est un terme que je ne connaissais pas, l'action si.

mais tu fais du C, non ? même si c'est pas sur 68k

Oui. Je connais les pointeurs, je sais attribuer une valeur a une variable via un pointeur, mais je ne savais pas que ca s'appelait un dereferencement stou.

bah voilà tu dormiras moins con ce soir

excellent tuto, j'ai presque tout compris aussi ^^

Bon bah j'peux supposer qu'il est assez clair alors
La suite pour bientôt (aujourd'hui ? demain ? dans 30 ans ? tout dépendra de mon humeur )

(alors rendez-vous au topic humeur pour que tu nous dises ca mdr)

fait :p
le soir même

lol

tres bien ^^

bon, retour au sujet. (j'le dis souvent ces temps-ci, attention adri !)