Coder rapidement des programmes interactifs - Page 6

Thibaut (./152) :
Est-ce infaillible ?

Thibaut (./152) :
Connait-on à coup sûr l'adresse de la table des handles sur n'importe quelle machine ?

Est-ce infaillible ?

Connait-on à coup sûr l'adresse de la table des handles sur n'importe quelle machine ?

Thibaut (./152) :
Est-ce infaillible

Folco (./153) :
Je crois que non

Lionel Debroux (./154) :
Ca paraît raisonnable

Thibaut (./152) :
On note l'adresse de n'importe quel symbole dans le processus (qui est forcément un twin du programme possédant le même nom ?).

Folco (./153) :
En tout cas, PreOS fait une manip très bizare au niveau des twins (qui font 6 octets quel que soit le programme), et je ne crois pas que les programmes read-only aient un twin.

Thibaut (./152) :
J'ai l'impression d'avoir vu FireHunter parler de ça récemment avec d'autres. Je vais relire.

PpHd (./156) :
Aucun programme exécuté par le kernel ne possède de twin. Le twin du programme initial est détruit (mais le handle est conservé pour éviter de tout faire planter)

[squalyl@pc2 ~]$ cat test1.c
#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv)
{
        char *a[3];

        printf("argv[0] contient %s\n",argv[0]);
        printf("avant exec(test2)\n");
        a[0]="tutu";
        a[1]="toto";
        a[2]=NULL;
        execvp("./test2",a);
        return 0;
}

[squalyl@pc2 ~]$ cat test2.c
#include <stdio.h>

int main(int argc, char **argv)
{
        printf("dans test2, argv[0]=%s\n",argv[0]);
        return 0;
}

[squalyl@pc2 ~]$ gcc test1.c -o test1
[squalyl@pc2 ~]$ gcc test2.c -o test2
[squalyl@pc2 ~]$ ./test1
argv[0] contient ./test1
avant exec(test2)
dans test2, argv[0]=tutu
[squalyl@pc2 ~]$

[squalyl@pc2 ~]$ cat test3.c
#include <stdio.h>
#include <unistd.h>

int main(int argc, char **argv)
{
        printf("argv[0] contient %s\n",argv[0]);
        printf("avant system(test2)\n");
        system("./test2");
        return 0;
}

[squalyl@pc2 ~]$ gcc test3.c -o test3
[squalyl@pc2 ~]$ ./test3
argv[0] contient ./test3
avant system(test2)
dans test2, argv[0]=./test2
[squalyl@pc2 ~]$

tu connais un moyen d'obtenir la dernière commande tapée dans Home ?

__Search_for_system_TEXT_EDIT__:
    | Search for the system TEXT_EDIT structure. We need it to retrieve the
    | home screen line handle.
    | Thanks to Samuel Stearley for this method.
    movea.l 0x10E*4(%%a5),%%a0 | HomeExecute.
    move.l 0xB1*4(%%a5),%%d0  | TE_select.

__Loop_search_system_TEXT_EDIT_loop__:
    addq.l #2,%%a0
    cmp.l (%%a0),%%d0
    bne.s __Loop_search_system_TEXT_EDIT_loop__
    
    | This line might be unsafe on future AMS versions, if TI puts the
    | TEXT_EDIT structure above 0x8000... Note that TI doing that would 
    | break many other programs too !
    move.w -4(%%a0),%%a0    | Pointer to the home text edit structure.

    move.w 34(%%a0),%%d0    | Take the handle of the home screen line.

Thibaut (./163) :
tu connais un moyen d'obtenir la dernière commande tapée dans Home ?

Thibaut (./163) :
FireHunter : alors, tu as pu remettre GTC proprement à partir de zero ?

#include <stdio.h>

char main(char arg[64])
{
   arg = SYMSTR(arg);
   return arf;
}

#include <stdio.h>

short main(char arg[64])
{
   arg = SYMSTR(arg);
   return strlen(arg);
}

Sasume (./173) :
Pas plutôt un char *[] ?

4. Les arguments transmis à la fonction main

4.1 Comment passer des arguments à un programme

La fonction main peut récupérer les valeurs des arguments fournis au programme lors de son lancement. Le mécanisme utilisé par l'utilisateur pour fournir ces informations dépend de l'environnement. Il peut s'agir de commandes de menu pour des environnements dits graphiques ou intégrés. Dans les environnements fonctionnant en mode texte (tels DOS ou UNIX), il s'agit de valeurs associées à la commande de lancement du programme (d'où le terme d'arguments de la ligne de commande). Voici un exemple où l'on demande l'exécution du programme nommé test, en lui transmettant des arguments :

test("caractères1", nombre1, "caractères2")

ou encore :

test("caractères1 nombre1 caractères2")



4.2 Comment récupérer ces arguments dans la fonction main

Ces paramètres sont des chaînes de caractères ou des nombres. Lorsqu'ils sont fournis entre des guillemets dans la ligne de commande, ils sont séparés par des espaces. On peut aussi les séparer par des virgules. Leur transmission à la fonction main (réalisée par le système) se fait selon les conventions suivantes :

* le premier argument reçu par la fonction main sera de type int et il représentera le nombre total de paramètres fournis dans la ligne de commande (le nom du programme compte lui-même pour un paramètre) ;
* le second argument reçu par la fonction main sera l'adresse d'un tableau de pointeurs, chaque pointeur désignant la chaîne correspondant à chacun des paramètres.

Ainsi, en écrivant l'entête de la fonction main comme ceci :

int main (int argc, char * argv[])nous obtiendrons :

* dans argc, le nombre total de paramètres ;
* à l'adresse argv[0], le premier paramètre, qui correspond au nom du programme sur PC. Sur TI, la chaine est vide ;
* à l'adresse argv[1], le second paramètre. Dans notre exemple, il s'agirait de la chaîne "caractères1" ;
* etc.

Voici un exemple de programme utilisant ces possibilités. Il est accompagné de trois exemples d'exécution. Nous avons supposé que notre programme se nommait tagada.

#include <stdio.h>

int main (int argc, char * argv[])
{
    int i;
    
    if (argc>1) for (i=1; i<argc; i++) printf ("Argument numero %d : %s\n", i, argv[i]);
        else printf ("Pas d'argument\n");

    return 0;
}

tagada()Pas d'argument

tagada("fraise tsointsoin")

Argument numero 1 : fraise
Argument numero 2 : tsointsoin

tagada("fraise", "tsointsoin")

Argument numero 1 : fraise
Argument numero 2 : tsointsoin