Discussion :

[kromartien]

Bonjour. Je projette d'écrire un programme C fonctionnant en ligne de commande. Pouvez vous m'aider sur la façon dont je devrais m'y prendre pour l'organisation?

Je pense notamment aux codes de sortie, à la gestion des entrées/sorties (option -o pour un fichier de sortie ?) , et plus généralement à l'architecture du programme.

Merci si vous me donnez des indications et des pistes pour pouvoir faire un code maintenable et modifiable et surtout pertinent.

Je me pose cette question de par l'utilisation d'un grand nombre de programmes C qui ne fonctionnent pas toujours de la même manière du point de vue de l'utilisateur.

[souviron34]

combien de paramètres ? quelles options ??

En général :

-v = verbose
-in ou -f = fichier entrée
-o = fichier sortie
-d = repertoire ou debug

[kromartien]

Oui merci pour la réponse. Alors donc il y a d'une part les arguments, et d'autre part les options (qui sont passées avant les arguments en général) avec une gestion de la ligne de commande.

Est ce que je devrais faire une hiérarchie des modules de code ( fonctions élémentaires, puis grosses fonctionnalités tirant parti de ces fonctions élémentaires) , et ne placer la gestion des options et des arguments que dans le main, avec les appels correspondants aux blocs de code.

D'une manière générale, par exemple pour une option verbose, faut il placer un test conditionnel lors de chaque appel à puts, où comment dissocier l'application des options du squelette du programme ?

Et pour la gestion des arguments, par exemple si je fais monprog *.txt, la liste des arguments est tous les fichiers *.txt, ça en fait un paquet. Ça doit vouloir dire que je ne peux utiliser le programme que sur une fichier à la fois, sinon c'est vain. Et képassa si je fais marcher le programme sur un -type d, un répertoire ?


En fait, en réfléchissant, j'aurai en effet besoin dans un premier temps

d'un mode verbeux (pour le débogage au moins dans un premier temps, j'ai implémenté certains puts de facto, après s'il sert l'utilisateur et plus le debugueur tant mieux )

d'un champ USAGE (Emmanuel m'a montré comment faire déjà) si le prog prends des arguments inattendus ou pas d'arguments

et d'une option qui permet de sélectionner la fonctionnalité du programme. En effet ce serait un programme du genre "double fonctionnalité" , la fonctionnalité serait sélectionnée par une des options.

Pour les tirets, comment ça marche ? Je mets tout ce qui est précédé par un tiret dans un char ** spécial, et tout le reste dans un autre char** ?

[Freed0]

Apparament tu bosses sous Unix... LA solution est donc getopt()

http://www.linux-kheops.com/doc/man/.../getopt.3.html

Pour le mode verbeux, j'initialise une variable verbose à 0, dans dans le switch-case qui suit le getopt, je fais verbose++ si l'option est utilisée.

Ensuite il suffit de faire des if (verbose) { ...

[kromartien]

ok ça marche sous Linux, il y a une bonne page de manuel avec des bons exemples. Je vais utiliser ça. Merci beaucoup.

[souviron34]

USAGE ce n'est pas une option ou un champ. C'est une fonction..

En général, tu fais comme ceci :

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
140
141
142
143
144
145
146
 
 
/*
 * U s a g e
 *
 */
static void Usage ( char *ProgName )
{
  fprintf (stderr, "\n For the %s program to run you must include the following parameter :\n",ProgName );
  fprintf (stderr, "\n -f filename      : input file");
  fprintf (stderr, "\n But you may also include the following parameter :\n");
  fprintf (stderr, "\n [-O]              : optimization flag");
  fprintf (stderr, "\n [-V]              : gives the software's version.");
  fprintf (stderr, "\n [-R directory]   : base directory where database is located.");
  fprintf (stderr, "\n                    [%s is the default]",getenv("PWD"));
  fprintf (stderr, "\n [-GIF]           : formatting image as GIF [the default is not GIF]");
  fprintf (stderr, "\n [-freq N]        : frequency (in seconds) at which server will watch");
  fprintf (stderr, "\n                    changes in realtime in the DB [60 is the default].");
  fprintf (stderr, "\n\n");
}
 
 
 
/*
 * C h e c k s _ O p t i o n s
 *
 */
static int Checks_Options ( int argc, char **argv )
{
 int   i, s = SUCCESS ;
 
 
 for ( i = 1 ; i < argc ; i++ )
   {
      /* Input file */
      if ( strcasecmp(argv[i], "-f") == 0 )
        {
	   if ( i == (argc-1) )
	     {
	       Usage(argv[0]);
	       return ERROR ;
	     }
 
	   FICHIER = argv[i+1] ;
	   i = i + 1 ;
	   continue ;
	}
 
      /* Version */
      if ( strcasecmp(argv[i], "-V") == 0 )
         {
           fprintf ( stderr, "\n VERSION %d\n",VERSION);
           continue ;
         }
 
      /* Optimisation */
      if ( strcasecmp(argv[i], "-O") == 0 )
        {
	 Optimize = True ;
              continue ;
        }
 
      /* Checks a directory was set to contain the database */
      if ( strcasecmp(argv[i], "-R") == 0 )
        {
	   if ( i == (argc-1) )
	     {
	       Usage(argv[0]);
	       return ERROR ;
	     }
 
	   Repertoire = argv[i+1] ;
	   i = i + 1 ;
	   continue ;
	}
 
 
      /* Checks if the GIF flag was set */
      if ( strcasecmp(argv[i], "-GIF") == 0 )
	{
	  WITHGIF = True ;
	  continue ;
	}
 
      /* Frequency of dababase checking in seconds */
      if ( (strcasecmp(argv[i], "-freq") == 0) ||
	   ((strncmp(argv[i], "-f", 2) == 0) && (argv[i][2] != 'd')) )
	{
	   if ( i == (argc-1) )
	     {
	       Usage(argv[0]);
	       return ERROR ;
	     }
	   sscanf ( argv[i+1], "%d", &Frequency );
	   i = i + 1 ;
	   continue ;
	}
 
      /* Checks if the local debug flag was set */
      if ( strcmp(argv[i], "-d") == 0 )
	{
	  DEBUG = True ;
	  continue ;
	}
    }
 
 if ( FICHIER == NULL )
   s = ERROR ;
 
 return s ;
}
 
 
/*
*******************
 
Programme principal 
 
*******************
*/
int main(int argc, char *argv[])
{
/* Initialisation des variables */
.....
 
/* 
--- Vérifie si on a bien le nombre MINIMUM d'arguments
*/
  if ( argc < 3 )
    {
      Usage(argv[0]);
      return EXIT_FAILURE ;
    }
 
/*
--- Vérifie quelles sont les options et aguments
*/
  if ( Checks_Options(argc, argv) == ERROR )
    {
      Usage(argv[0]);
      return EXIT_FAILURE ;
    }
 
....
   return EXIT_SUCCESS ;
}

Ceci n'est bien sûr qu'un exemple... Là il n'y a que des options et UN paramètre obligatoire (-f filename).

Maintenant dans ton main, tu devrais avoir après ces vérifications l'appel à une fonction de dispatch, suivant ce que tu veux faire.

Et enfin, effectivement, une structure pyramidale, des fonctionalités les plus larges (métiers) vers les plus fines (implantations) .
[Exemple : Rotate_Image pour le métier .... Rotate_Pixel en dessous.]

[kromartien]

Ouh ... Des nouveaux mots clé (et oui je suis faible) le continue est-il indispensable ?

Pour les flux alors c'est stderr si quelque chose se passe mal, si pas d'argument fichier je viens lire stdin, si pas d'option -o (output) , j'écris sur stdout.

Pour les return, je me suis astreint jusqu'à maintenant à ne les placer qu'en sortie de bloc, de façon à ce que même si le programme continue après une instruction retrun, il ne se passera rien. Est-ce inutile?

[Freed0]

Oulà, contente toi d'observer la fonction Usage, oublie la fonction Check_options (compliquée inutilement à mon gout)

[kromartien]

ouaip. Trop tard j'ai mordu dans le fruit de la connaissance mais je ne recopierai pas une fonction sans en comprendre bien le fonctionnement.

[souviron34]

j'ai juste dis que c'était un exemple

C'est juste pour monter le traitement en général suivi..

si pas d'argument fichier je viens lire stdin, si pas d'option -o (output) , j'écris sur stdout.

En fait c'est quasi encore plus simple que ça. Comme en C les flux d'entrée et de sortie sont des fichiers, il suffit de faire 2 variables FILEIN et FILEOUT, et des les intialiser à stdin et stdout.

Et si il y a les paramètres, tu ouvres les fichiers (et bien sûr pour fermer tu vérifies si ce n'est ni stdin ni stdout ).

Pour les return, je me suis astreint jusqu'à maintenant à ne les placer qu'en sortie de bloc, de façon à ce que même si le programme continue après une instruction retrun, il ne se passera rien. Est-ce inutile?

Non c'est tout à fait correct.

En fait dans le code ici c'est juste pour ne pas faire un gros if..else. et sauter les if suivants. Ta manière est plus "correcte", la mienne est plus "rapide" (un tout petit peu..). Mais tu peux aussi faire un switch ( argv[i][1] ) qui switchera sur la première lettre après le '-'.

[souviron34]

Oulà, contente toi d'observer la fonction Usage, oublie la fonction Check_options (compliquée inutilement à mon gout)

c'est uniquement pour déporter le code en dehors du main, avoir une fonction de vérification des options éventuellement dans une bibliothèque, et encore une fois ça n'est qu'un exemple où j'ai mis plusieurs types de choses et comment interpréter les options correspondantes...