Discussion :

[Kr00pS]

Bonjour !

Je réalise un programme et il doit traiter des commandes, il demande à l'utilisateur ce qu'il veut faire, l'utilisateur tape sa commande et le programme la traite (help pour afficher la fonction display_help par exemple).

J'ai pensé à strcmp mais je voulais savoir s'il y avait d'autres méthodes plus "élégantes" que plusieurs if (strcmp(machin, machin2 == 0)...

Merci beaucoup.

Kr00pS

[DaZumba]

J'ai pensé à strcmp mais je voulais savoir s'il y avait d'autres méthodes plus "élégantes" que plusieurs if (strcmp(machin, machin2 == 0)...

Oui, tu boucles sur un tableau de chaine de caracteres tant que strcmp() ne renvoit pas 0 (et que l'on ne depasse pas les limites du tableau).
Tu peux aussi faire un tableau de structures qui regroupent le nom de la commande et un pointeur vers la fonction associee a cette commande.

[Kr00pS]

Merci pour la réponse mais ce sont les trucs que je maîtrise le moins en C (pointeurs de fonctions et tableaux de structures, tableaux de chaînes).

Encore une méthode pour un simple débutant comme moi ?

[Médinoc]

Ben la plus simple c'est les IF.
Je ne crois pas qu'il y ait de méthode "entre les deux".
Par contre, on peut t'aider pour apprendre le reste.
Déjà, les pointeurs de fonction:

La plus grande erreur avec les pointeurs de fonction consiste à ne pas utiliser de typedef, ce qui rend leur déclaration longue et fastidieuse (il n'y a qu'à voir le prototype de la fonction standard signal() : tout simplement horrible).
Cela peut être facilement corrigé:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
/* Une fonction qui recopie une chaîne de caractères dans un espace plus grand.
 * Peut être utile pour faire un strcat ensuite,
 * mais j'ai choisi cette fonction pour avoir un prototype intéressant
 */
char *AllocStringAdd(char const *chnOrig, size_t ajout)
{
	size_t taille = strlen(chnOrig) + ajout + 1;
	char *chnRetour = malloc(taille);
	if(chnRetour != NULL)
	{
		/* Recopie la chaine, et le \0 avec */
		memcpy(chnRetour, chnOrig, taille+1);
	}
	return chnRetour;
}

Pour utiliser un pointeur capable d'appeler cette fonction, le typedef correspondant est ceci:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

typedef char * (*PT_FONCTION)(char const *, size_t);

Ici, PT_FONCTION est le type "pointeur de fonction" : C'est un pointeur vers une fonction prenant un char const * et un size_t en paramètre et retournant un char *
Et à présent, c'est facile à utiliser:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
void UneFonction(int a)
{
	PT_FONCTION pFonc = NULL;
	char *chn = NULL;
 
	if(a == 0)
		pFonc = AllocStringAdd;
	else
		pFonc = UneAutreFonctionAvecLeMemePrototype;
 
	/* On utilise la fonction pointee */
	chn = pFonc("blabla", 8);
	puts(chn);
	free(chn);
}

Si après ceci tu arrives à utiliser des pointeurs de fonctions, tu devrais réussir à faire marcher le tableau de structures.
Dans chaque structure, il faut une chaîne et un pointeur de fonction.

[Kr00pS]

Merci bien pour ce petit cours.

Je vais essayer de faire ça proprement.

Kr00pS

[Kr00pS]

Bon, j'ai essayé, mais je ne trouve vraiment pas l'erreur, faut dire que c'est pointu aussi ton truc, des tableaux de structures avec des pointeurs de fonctions dedans, ça fait beaucoup de trucs à assimiler.

C'est un peu en désoudre car je veux m'assurer que mon programme marche avant de répartir les fonctions et structures dans plusieurs fichiers.

Beaucoup d'erreurs, pourtant je vois pas pourquoi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
/* ---------------------------------------------------------------------
   (c) TE 2006
   Project      : BINDSASSEMBLER
   Function     : A binds creator for Counter-Strike 1.5 .
   Module       : MAIN
   File         : main.c
   Created      : 14-06-2006
   Modified     : 14-06-2006
   --------------------------------------------------------------------- */
 
/* ---------------------------------------------------------------------
   Log
 
   0.0 -> 14-06-2006 Created.
   --------------------------------------------------------------------- */
 
#ifdef __cplusplus
#error This code works only with C, not C++.
#endif
 
#include <stdio.h>
#include <stdlib.h>
/* Library for neatly data capture. */
#include "KLIB/datacapture/datacapture.h"
 
#define DGB 0
 
typedef struct
{
    FILE* file;
} bindsAssembler_s;
 
typedef struct
{
    char* commande;
    typedef void (p_command)(void);
} command_s;
 
static void init_struct_main(bindsAssembler_s *this)
{
    const char* fname = "autoexec.cfg";
 
    this->file = fopen(fname, "w+"); 
 
    if (this->file == NULL)
    {
	ferror(this->file);
	exit(EXIT_FAILURE);
    }
}
 
static void add_binds(void)
{
    /* ... */
}
 
static void display_help(void)
{
    printf("Help :\n\n"
	   "Keywords*  : (pistols) usp glock deagle p228 fiveseven beretta\n"
	   "           : (smg) mp5 tmp p90 mac10 ump\n"
	   "           : (rifles) ak47 sg552 m4a1 aug\n"
	   "           : (snipers) awp scout sg1 sg550\n"
	   "           : (machine gun) m249\n"
	   "*Warning : Type keywords in small characters only.\n\n");
}
 
static void ask_work(bindsAssembler_s *this)
{
    char data[20];
 
    printf("Welcome to BindsAssembler (first version) !\n");
    printf("What do you want to do (type help for display the help) ? ");
    K_datacapture(data, sizeof data, stdin);
 
    command_s command[2] = 
    {
	{"help", command[0]->p_command = display_help},
	{"add binds", command[1]->p_command = add_binds}
    };
 
    /* Call display_help. */
    command[0];
}
 
 
static void do_process(void)
{
    bindsAssembler_s user;
 
    init_struct(&user);
 
    ask_work(&user);
}
 
int main (int argc, char** argv)
{
    do_process();
 
    return 0;
}

Erreurs en compilant :

main.c:38: erreur: syntax error before «typedef»
main.c:38: attention : pas de point virgule à la fin de la structure ou de l'union
main.c:39: attention : type defaults to «int» in declaration of «command_s»
main.c:39: attention : la définition de données n'a pas de type ni de classe de stockage
main.c: Dans la fonction «ask_work» :
main.c:63: erreur: syntax error before «command»
main.c:54: attention : unused parameter «this»
main.c: Dans la fonction «do_process» :
main.c:91: attention : implicit declaration of function «init_struct»
main.c: Dans la fonction «main» :
main.c:96: attention : unused parameter «argc»
main.c:96: attention : unused parameter «argv»
main.c:38: erreur: syntax error before «typedef»
main.c:38: attention : pas de point virgule à la fin de la structure ou de l'union
main.c:39: attention : type defaults to «int» in declaration of «command_s»
main.c:39: attention : la définition de données n'a pas de type ni de classe de stockage
main.c: Dans la fonction «ask_work» :
main.c:63: erreur: syntax error before «command»
main.c:54: attention : unused parameter «this»
main.c: Dans la fonction «do_process» :
main.c:91: attention : implicit declaration of function «init_struct»
main.c: Dans la fonction «main» :
main.c:96: attention : unused parameter «argc»
main.c:96: attention : unused parameter «argv»

PS : il peut y avoir des fautes énormes vu que c'est en Anglais et j'ai un peu de mal avec.

Merci.

Kr00pS

[Emmanuel Delahaye]

Je réalise un programme et il doit traiter des commandes, il demande à l'utilisateur ce qu'il veut faire, l'utilisateur tape sa commande et le programme la traite (help pour afficher la fonction display_help par exemple).

J'ai pensé à strcmp mais je voulais savoir s'il y avait d'autres méthodes plus "élégantes" que plusieurs if (strcmp(machin, machin2 == 0)...

http://emmanuel-delahaye.developpez.com/clib.htm
Module CI (Command Interpretor)

[Emmanuel Delahaye]

Merci pour la réponse mais ce sont les trucs que je maîtrise le moins en C (pointeurs de fonctions et tableaux de structures, tableaux de chaînes).

Alors c'est le moment de t'y mettre. Commence par t'entraîner avec les pointeurs de fonctions.

[Médinoc]

J'ai fait quelques menues corrections, voici les extraits que j'ai modifiés :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
/* MED - Ici, le typedef sera très bien
(mais il manquait l'étoile, et je le mets en majuscules (une habitude de windowsien)) */
typedef void (*P_COMMAND)(void);
 
typedef struct
{
    FILE* file;
} bindsAssembler_s;
 
 
typedef struct
{
    /* MED - Je rajoute un const, puisque tu te bases sur des chaînes constantes */
    char const * commande;
    /* MED - Pas ici, le typedef : là, il faut déclarer un pointeur
    typedef void (p_command)(void); */
    P_COMMAND pCommand;
} command_s;
 
static void ask_work(bindsAssembler_s *this)
{
    char data[20];
 
    printf("Welcome to BindsAssembler (first version) !\n");
    printf("What do you want to do (type help for display the help) ? ");
    K_datacapture(data, sizeof data, stdin);
 
    /* MED - Je rajoute un bloc, 
    car mon compilo ne supporte pas les déclarations en milieu de bloc */
    {
        /* MED - Ah, presque...
        command_s command[2] = 
        {
        {"help", command[0]->p_command = display_help},
        {"add binds", command[1]->p_command = add_binds}
        }; */
        command_s theCommands[2] = {
         {"help", display_help},
         {"add binds", add_binds}
        };
 
        /* Call display_help. */
        /* MED - Raté de peu... 
        command[0]; */
        theCommands[0].pCommand();
    }/* MED */
}

[Emmanuel Delahaye]

Beaucoup d'erreurs, pourtant je vois pas pourquoi :

Ce code compile. Pose des questions si tu ne comprends pas...

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
 
/* ---------------------------------------------------------------------
   (c) TE 2006
   Project      : BINDSASSEMBLER
   Function     : A binds creator for Counter-Strike 1.5 .
   Module       : MAIN
   File         : main.c
   Created      : 14-06-2006
   Modified     : 14-06-2006
   --------------------------------------------------------------------- */
 
/* ---------------------------------------------------------------------
   Log
 
   0.0 -> 14-06-2006 Created.
   --------------------------------------------------------------------- */
 
#ifdef __cplusplus
#error This code works only with C, not C++.
#endif
 
#include <stdio.h>
#include <stdlib.h>
/* Library for neatly data capture. */
#if 0
#include "KLIB/datacapture/datacapture.h"
#else
/* -ed- Comme d'hab, code incomplet... va falloir improviser... */
#include <string.h>
 
static void purge (FILE * fp)
{
   int c;
   while ((c = fgetc (fp)) != '\n' && c != EOF)
   {
   }
}
 
static void clean (char *s, FILE * fp)
{
   /* search ... */
   char *p = strchr (s, '\n');  /* <string.h> */
   if (p != NULL)
   {
      /* ... and kill */
      *p = 0;
   }
   else
   {
      purge (fp);
   }
}
 
static void K_datacapture(char const *s, size_t size, FILE *fp)
{
   fgets(s, size, fp);
}
 
#endif
 
typedef void (command_f)(void);
 
typedef struct
{
   FILE* file;
}
bindsAssembler_s;
 
typedef struct
{
   char* commande;
   command_f *p_command;
 
}
command_s;
 
static void init_struct(bindsAssembler_s *this)
{
   const char* fname = "autoexec.cfg";
 
   this->file = fopen(fname, "w+");
 
   if (this->file == NULL)
   {
      ferror(this->file);
      exit(EXIT_FAILURE);
   }
}
 
static void add_binds(void)
{
   /* ... */
}
 
static void display_help(void)
{
   printf("Help :\n\n"
          "Keywords*  : (pistols) usp glock deagle p228 fiveseven beretta\n"
          "           : (smg) mp5 tmp p90 mac10 ump\n"
          "           : (rifles) ak47 sg552 m4a1 aug\n"
          "           : (snipers) awp scout sg1 sg550\n"
          "           : (machine gun) m249\n"
          "*Warning : Type keywords in small characters only.\n\n");
}
 
static void ask_work(bindsAssembler_s *this)
{
   char data[20];
 
   printf("Welcome to BindsAssembler (first version) !\n");
   printf("What do you want to do (type help for display the help) ? ");
   K_datacapture(data, sizeof data, stdin);
 
   command_s command[] =
      {
         {"help", display_help},
         {"add binds", add_binds}
      };
 
   /* Call display_help. */
   command[0];
}
 
 
static void do_process(void)
{
   bindsAssembler_s user;
 
   init_struct(&user);
 
   ask_work(&user);
}
 
int main ()
{
   do_process();
 
   return 0;
}

[Kr00pS]

Merci à vous !

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

/* -ed- Comme d'hab, code incomplet... va falloir improviser... */

Oops, désolé, j'ai oublié !
De toute façon, c'est exactement ça.

Ca marche !

Kr00pS

[Kr00pS]

C'est encore moi !

J'ai codé un peu le "moteur" de l'interpreteur de commandes, ça ne marche pas très bien.

Quand je tape une fois la commande, ça s'affiche normalement, quand je la retape tout de suite, ça ne marche pas, quand je refais cette opération plusieurs fois à la suite, j'obtiens un "Erreur de segmentation".

Voici mon code :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
/* ---------------------------------------------------------------------
   (c) TE 2006
   Project      : BINDSASSEMBLER
   Function     : A binds creator for Counter-Strike 1.5 .
   Module       : MAIN
   File         : main.c
   Created      : 14-06-2006
   Modified     : 14-06-2006
   --------------------------------------------------------------------- */
 
/* ---------------------------------------------------------------------
   Log
 
   0.0 -> 14-06-2006 Created.
   --------------------------------------------------------------------- */
 
#ifdef __cplusplus
#error This code works only with C, not C++.
#endif
 
#include <stdio.h>
#include <stdlib.h>
/* Library for neatly data capture. */
#include "KLIB/datacapture/datacapture.h"
 
#define DGB 0
 
typedef void (command_f)(void);
 
typedef struct
{
   FILE* file;
}
bindsAssembler_s;
 
typedef struct
{
   char* name;
   command_f *p_command;
}
command_s;
 
static void init_struct(bindsAssembler_s *this)
{
   const char* fname = "autoexec.cfg";
 
   this->file = fopen(fname, "w+");
 
   if (this->file == NULL)
   {
      ferror(this->file);
      exit(EXIT_FAILURE);
   }
}
 
static void add_binds(void)
{
    printf("Add binds...");
}
 
static void display_help(void)
{
   printf("Help :\n\n"
          "Keywords*  : (pistols) usp glock deagle p228 fiveseven beretta\n"
          "           : (smg) mp5 tmp p90 mac10 ump\n"
          "           : (rifles) ak47 sg552 m4a1 aug\n"
          "           : (snipers) awp scout sg1 sg550\n"
          "           : (machine gun) m249\n"
          "*Warning : Type keywords in small characters only.\n\n");
}
 
static void quit_program(void)
{
    exit(EXIT_FAILURE);
}
 
static void ask_work(bindsAssembler_s *this)
{
   char data[20];
   int ret = 1, i, z;
 
   command_s command[3] = {
         {"help", display_help},
         {"add binds", add_binds},
         {"quit", quit_program}
   };
 
   printf("Welcome to BindsAssembler (first version) !\n");
 
   for (i = 0; ret != 0; i++)
   {
       printf("What do you want to do (type help for display the help) ? ");
       K_datacapture(data, sizeof data, stdin);
 
       if (strcmp(data, command[i].name) == 0)
       {
	       command[i].p_command();
       }
 
       /* On remet i a 0 s'il vaut plus de 2 (s'il y a un debordement de la
	  taille du tableau command. */
       if (i > 2)
       {
	   i = 0;
       }
 
       /* La boucle s'arrete quand l'utilisateur tape quit. */
       ret = strcmp(data, command[2].name);
   }
}
 
 
static void do_process(void)
{
   bindsAssembler_s user;
 
   init_struct(&user);
 
   ask_work(&user);
}
 
int main ()
{
   do_process();
 
   return 0;
}

Ce que donne la console :

kr00ps@kr00ps-desktop:~/devel/c/console/BindsAssembler$ ./ba
Welcome to BindsAssembler (first version) !
What do you want to do (type help for display the help) ? help
Help :

Keywords* : (pistols) usp glock deagle p228 fiveseven beretta
: (smg) mp5 tmp p90 mac10 ump
: (rifles) ak47 sg552 m4a1 aug
: (snipers) awp scout sg1 sg550
: (machine gun) m249
*Warning : Type keywords in small characters only.

What do you want to do (type help for display the help) ? help
What do you want to do (type help for display the help) ? help
What do you want to do (type help for display the help) ? help
Erreur de segmentation

Merci.

Kr00pS

[Emmanuel Delahaye]

J'ai codé un peu le "moteur" de l'interpreteur de commandes, ça ne marche pas très bien.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/* static void ask_work(bindsAssembler_s *this)
{
   char data[20];
   int ret = 1, i, z;
 
   command_s command[3] = {
         {"help", display_help},
         {"add binds", add_binds},
         {"quit", quit_program}
   };
 
   printf("Welcome to BindsAssembler (first version) !\n");
 
   for (i = 0; ret != 0; i++)
   {
       printf("What do you want to do (type help for display the help) ? ");
       K_datacapture(data, sizeof data, stdin);
 
       if (strcmp(data, command[i].name) == 0)
       {
	       command[i].p_command();
       }
 
       /* On remet i a 0 s'il vaut plus de 2 (s'il y a un debordement de la
	  taille du tableau command. */
       if (i > 2)
       {
	   i = 0;
       }
 
       /* La boucle s'arrete quand l'utilisateur tape quit. */
       ret = strcmp(data, command[2].name);
   }

Commence par ecrire l'algo, parce que là, c'est un peu n'importe quoi...
Il y a certes une boucle de commande mais il y aussi une boucle de recherche après chaque commande pour savoir ce qu'on a à faire... (ou erreur). En principe, le 'quit' n'est pas dans le tableau. Il est traité 'à part' (avant toute autre chose)

[Jean-Marc.Bourguet]

Petite remarque: si j'avais à écrire un interpréteur, je regarderais si quelque chose d'existant ne me convient pas. tcl par exemple a été conçu pour être le langage de contrôles d'applications, d'autres langages de script ont été conçu pour être des langages interprétés mais ont des interfaces pour faire ce genre de chose.

[Kr00pS]

Commence par ecrire l'algo, parce que là, c'est un peu n'importe quoi...

J'ai déjà conçu l'algorithme :

Tant que l'utilisateur ne demande pas à quitter, on compare une à une les chaines, si la chaîne entrée par l'utilisateur est identique à un nom d'une commande alors on execute la fonction qui est associée à cette commande.
Si l'indice du tableau des commandes est superieur au nombre de commande alors on remet cet indice à 0.

Je vois pas l'erreur dans l'algo...

Il y a certes une boucle de commande mais il y aussi une boucle de recherche après chaque commande pour savoir ce qu'on a à faire... (ou erreur). En principe, le 'quit' n'est pas dans le tableau. Il est traité 'à part' (avant toute autre chose)

La boucle de recherche c'est celle qui compare une à une la chaîne de l'utilisateur à celle des commandes.

L'erreur, c'est un tour de boucle supplémentaire, pas besoin d'afficher un message.

Petite remarque: si j'avais à écrire un interpréteur, je regarderais si quelque chose d'existant ne me convient pas. tcl par exemple a été conçu pour être le langage de contrôles d'applications, d'autres langages de script ont été conçu pour être des langages interprétés mais ont des interfaces pour faire ce genre de chose.

Je suis d'accord, le C n'est pas approprié pour tout les projets mais je veux simplement m'entrainer et arriver à maîtriser ce langage (c'est dur !).

Kr00pS

[Médinoc]

Le code n'est pas conforme à l'algorithme : Là, à chaque commande, tu la compare à UNE chaîne.

Il te faut une seconde boucle imbriquée au lieu de baser la comparaison sur la même boucle.
(À ta place, je mettrais même cette partie (boucle de recherche dans la liste après l'entrée du mot) dans une fonction)

[Kr00pS]

Hum, c'est résolu, j'avais même pas vu les deux boucles qu'il fallait mettre, je devais être fatigué (et très chiant par la même occasion).

Merci à vous tous.

Kr00pS

[Emmanuel Delahaye]

je devais être fatigué (et très chiant par la même occasion).

On en a vu d'autres !