Extraction d'option commande UNIX

Bonjour,
voila je suis ici pour vous demander votre avis.
mon projet consiste à réécrire une fonction Unix.
celle-ci peu par conséquent prendre un certain nombre d'option (inconnues à l'avance).
je cherche la meilleur façon de récupérer ces options.
pour l'instant je test les chaines de caractères donné en argument (grâce à argc et argv).
pour toute les chaines de argv je commence par tester si le "-" (caractéristique d'une option) est présent. Si oui je teste le reste de la chaine pour voir si c'est une option que je connais. En fonction de cela je stocke un chiffre particulier dans un tableau.

exemple : fonction -i -d -a fic1 fic2
ici les option sont i d et a, je stockerai dans mon tableau 0 1 et 2.

Est-ce la meilleur façon de procéder ? Avez vous d'autre idées ?

d'avance, merci.

Bonsoir,

UNIX offre getopt(), qui sert à cela et existe pratiquement depuis le début.

Bon courage.

C'est déjà une bonne première approche. Mais pour être pleinement "unix", il faut aussi supporter les commandes du style fonction -ida fic1 fic2. Tu n'es plus très loin de cela. Pour ta culture, sache également que la fonction POSIX getopt permet de récupérer facilement les options de ligne de commande.

je vais compléter un peu mon premier post.
Je suis dans le cadre d'un projet en langage C. Les codes sont réalisé et utilisé sous windows. Je n'ai pas le droit d'utiliser de choses "déjà faîtes" (même pas string.h et son lot de fonction, nous devons re coder par exemple strlen si nous en avons besoin).
c'est pour cela que j'analyse les chaines passé en arguments.

Pour compléter mon message précédent également : tu peux aussi utiliser un simple entier à la place d'un tableau pour stcoker les différentes options activées. Les bits de cet entier remplaceront les cases du tableau. Mais bon, cela n'est intéressant que si tu as beaucoup d'options.

J'ai effectivement beaucoup d'options.
Il s'agit de la fonction diff dont les options sont :

Citation:

Usage: diff [OPTION]... FICHIERS
Comparer les fichiers ligne par ligne

-i --ignore-case ignorer les différences de casses dans le contenu des fichiers
--ignore-file-name-case ignorer la casse lors de la comparaison des noms de fichiers
--no-ignore-file-name-case tenir compte de la casse lors de la comparaison des noms de fichiers
-E --ignore-tab-expansion ignorer les changements liés à l'expansion des tabulations
-b --ignore-space-change ignorer les changements dans l'espacement
-w --ignore-all-space ignorer tout blanc d'espacement
-B --ignore-blank-lines ignorer les changements dont toutes les lignes sont blanches
-I EXPREG --ignore-matching-lines=EXPREG ignorer les différences dont les lignes concordent à l'EXPression RÉGulière
--strip-trailing-cr éliminer les retours de chariot de l'entrée.
-a --text traiter tous les fichiers comme des textes.

-c -C N --context[=N] afficher N lignes de contexte (3 par défaut)
-u -U N --unified[=N] afficher N lignes du contexte unifié (3 par défaut)
--label ÉTIQ utiliser l'ÉTIQuette comme nom de fichier.
-p --show-c-function identifier la fonction contenant chaque différence.
-F EXPREG
--show-function-line=EXPREG
afficher la ligne la plus récente qui concorde
avec l'EXPression RÉGulière
-q --brief indiquer seulement si les fichiers diffèrent ou non
-e --ed générer un script pour « ed »
--normal produire un « diff » en format normal
-n --rcs générer un fichier de type « diff » en format RCS
-y --side-by-side afficher la sortie sur deux colonnes
-w N --width=N limiter la sortie à N caractères par ligne (130 par défaut)
--left-column afficher seulement la colonne de gauche pour les lignes identiques
--suppress-common-lines ne pas afficher les lignes identiques
-D NOM --ifdef=NOM afficher la fusion des fichiers en indiquant les différences par des « #ifdef NAME » dans le « diff » produit
--GTYPE-group-format=GFMT similaire, mais formater les groupes
d'entrée GTYPE avec GFMT
--line-format=LFMT similaire, mais formater toutes les lignes d'entrée avec LFMT
--LTYPE-line-format=LFMT similaire, mais formater les lignes
d'entrée LTYPE avec LFMT
LTYPE peut être soit « old », « new », ou « unchanged ». GTYPE prend une des valeurs de LTYPE ou « changed ».
GFMT peut contenir:
%< pour marquer les lignes du FICHIER1
%> pour marquer les lignes du FICHIER2
%= pour marquer les lignes identiques entre FICHIER1 et FICHIER2
%[-][LARGEUR][.[PREC]]{doxX}LETTRE, les spécifications de LETTRE
sont identiques à la notation que l'on retrouve dans « printf() »
dont les codes possibles de LETTRE sont
en majuscule pour le nouveau groupe,
en minuscules pour l'ancien groupe:
F numéro de la première ligne
L numéro de la dernière ligne
N nombre de lignes = L-F+1
E F-1
M L+1
LFMT peut contenir:
%L pour le contenu de la ligne
%l pour le contenu de la ligne sans fin de ligne
%[-][LARGEUR][.[PREC]]{doxX}n la spécification du numéro de ligne
d'entrée selon le format de printf()
GFMT ou LFMT peuvent contenir:
%% %
%c« C » le caractère « C » lui-même
%c'\OOO» le caractère dont le code octal est OOO

-l --paginate relayer la sortie à « pr » afin de la paginer
-t --expand-tabs étaler les tabulateurs en espaces dans la sortie.
-T --initial-tab aligner les tabulateurs par l'ajout d'un tabulateur de préfixe

-r --recursive comparer récursivement les sous-répertoires présents
-N --new-file traiter les fichiers absents comme des fichiers vides
--unidirectional-new-file traiter les fichiers absents comme vides
-s --report-identical-files indiquer si les deux fichiers sont identiques
-x PAT --exclude=PAT exclure les fichiers dont les noms concordent avec le PATron
-X FICHIER --exclude-from=FICHIER exclure les fichiers dont les noms
concordent à ceux contenus dans le FICHIER
-S FICHIER --starting-file=FICHIER débuter la comparaison des
répertoires par le FICHIER
--from-file=FICHIER1
comparer le FICHIER1 à toutes les opérandes.
FICHIER1 peut être un répertoire.
--to-file=FICHIER2
comparer toutes les opérandes à FICHIER2.
FICHIER2 peut être un répertoire.

--horizon-lines=N retenir N lignes ayant des préfixes et suffixes identiques
-d --minimal si possible afficher le plus petit ensemble de différences.
--speed-large-files traiter de grands fichiers et ayant plusieurs petits changements dispersés

-v --version afficher le nom et la version du logiciel
--help afficher l'aide-mémoire

FICHIERS sont « FICHIER1 FICHIER2 » ou « RÉP1 RÉP2 » ou « RÉP FICHIER... » ou «FICHIER... RÉP'.
Si --from-file ou --to-file est fournie, il n'y a pas de restriction sur les FICHIERS.
Si le FICHIER spécifié est « - » alors lire de l'entrée standard.

Cette histoire d'entier me plaît mais je ne vois pas bien comment l'utiliser.

Supposons que notre commande supporte nb_options options, numérotées de 0 à nb_options - 1. Pendant l'analyse de la commande, nous allons utiliser les bits d'une variable de type int pour représenter les options actives. Pseudocode :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 int main(int argc, char *argv[]) { int mes_flags = 0; // Les bits de cet entier serviront a representer les options actives. Initialement, on met tous les bits a zero. ... // Analyse de la commande ... for(i = 0; i < nb_options; i++) if (option i trouvee) SET(mes_flags, i); // Activer le bit i de mes_flags. // Execution de la commande Traitement ... Traitement ... if (GET(mes_flags, 0)) // Si le bit 0 de mes_flags est active ... Traitement specifique a l option 0 ... Traitement ... Traitement ... if (GET(mes_flags, 1)) // Si le bit 0 de mes_flags est active ... Traitement specifique a l option 1 ... ... return 0; }
Activer ou allumer un bit veut dire le mettre à 1. L'effacer ou l'éteindre veut dire le mettre à 0 mais ici, nous n'avions eu jamais besoin d'effacer un bit. Tu trouveras l'implémentation des macros SET et GET dans la FAQ et une explication des opérateurs de manipulation de bits dans ce tutoriel.

Dans ton cas, on a 40 options, si j'ai bien compté, donc il faudra un entier de 64 bits pour stocker les flags. Or, si tu veux programmer en C90, il n'y a aucun type entier qui soit garanti avoir une taille minimale de 64 bits. Tu peux toujours utiliser des combinaisons de variables mais ça devient déjà un peu compliqué. Dans ce cas, les champs de bits se révèlent fort intéressants. Si tu programmes en C99 (autrement dit, si tu utilises un compilateur moderne autre que celui de M$ :lol:), tu as des entiers de taille manimale égale à 64 bits (les long long par exemple) donc tu n'es pas obligé d'utiliser les champs de bits. Si tu devras plus tard supporter plus de 64 options et ben, re champs de bits ;).

ok merci beaucoup pour ces renseignements :ccool:
je vais plancher la dessus !! :mouarf: