Nous sommes tenus de compiler des codes sources C en utilisant gcc de cette manière:compiler avec -ansi -pedantic -Wall bascule automatiquement avec gcc
gcc -ansi -pedantic -Wall program.c
Je me demande comment puis-je automatiser "ce quand je entrez:
gcc program.c
Il se compilera automatiquement avec les 3 commutateurs. Est-ce possible?
Pour automatiser la construction d'un nombre quelconque d'étapes de construction/de paramètres complexes, vous devez utiliser un makefile.
Une fois que vous avez un makefile vous devez simplement taper: make
alias gcc="gcc -ansi -pedantic -Wall"
Mais comme dit @ Brian, vous devriez vraiment utiliser un makefile, ou mieux, un système de construction comme CMake ou SCons.
Je l'appellerais quelque chose en plus de 'gcc' de sorte que si jamais je voulais l'utiliser en mode non fou-naggy, je pourrais encore appeler' gcc'. – nategoose
@nategoose: Si vous voulez appeler "plain" gcc sans invoquer l'alias, vous devez placer une barre oblique inverse devant la commande \ gcc pour empêcher la substitution d'alias. – dadinck
Un makefile serait la manière traditionnelle, en particulier dans le cadre d'un processus de construction plus important.
Si vous voulez souvent construire sans makefile, vous pouvez définir un alias dans votre .bashrc ou équivalent: alias gcc=gcc -ansi -pedantic -Wall.
Vous pouvez également utiliser les règles implicites de make, de sorte que vous n'ayez pas besoin d'écrire un makefile pour chaque programme. Make appellera automatiquement le compilateur si vous dites make foo et qu'il existe un fichier foo.c dans le répertoire courant. Pour ajouter des indicateurs, définissez la variable CFLAGS dans votre environnement, par ex. dans bash, ajoutez export CFLAGS="-Wall -pedantic -ansi" à .bashrc. Si votre programme dépend de plusieurs fichiers, vous devrez créer un fichier makefile, mais pour la compilation C, vous pouvez vous contenter de listes de dépendances seulement si l'une d'elles a le même nom de base qu'une cible.
Par exemple, pour ce makefile:
# Makefile
foo:foo.o bar.o
en cours d'exécution make exécutera les commandes
gcc $CFLAGS -c -o foo.o foo.c
gcc $CFLAGS -c -o bar.o bar.c
gcc -o foo foo.o bar.o
sans avoir à ajouter des règles.
Vous pouvez utiliser un script shell qui prend quelques indices en fonction de son appel et appelle make après avoir défini CFLAGS de manière appropriée pour la construction ponctuelle occasionnelle. Disons que vous avez /usr/bin/compile, qui est un script shell qui regarde $0 pour voir quel nom l'a effectivement appelé. Vous pouvez ensuite créer des liens symboliques qu'il pedantic nommé, fullwarn, etc.
Dans le script shell lui-même, quelque chose comme:
OLDCFLAGS=$CFLAGS
WHATAMI=$(basename $0)
case "$WHATAMI" in
pedantic)
export CFLAGS="-Wall -pedantic -ansi"
make [email protected]
exit $?
;;
c99)
export CFLAGS="-std=c99 ... ... ..."
....
Ensuite, pour compiler foo.c avec les drapeaux Naggy supplémentaires:
pedantic foo
Ceci est pratique, comme je l'ai dit pour unique construit, par exemple, essayer de compiler le code que quelqu'un a écrit dans une question, ou travailler sur la façon d'utiliser une nouvelle bibliothèque , etc.
Pour toute autre chose, utilisez simplement un makefile, comme d'autres l'ont dit.
Downvoted pour proposer un Makefile codé en dur (et cassé) quand les règles implicites avec 'export CFLAGS = ...' dans l'environnement font précisément ce que Jef Ty veut. (Voir la réponse de Scott Wales). –
@Matt B: Le but du fichier makefile était simplement d'introduire le concept d'un makefile tout en donnant l'exemple le plus simple possible qui fonctionnera en tapant make. Sans utiliser de règles implicites. J'ai enlevé l'exemple cependant. Il est très possible que l'OP veuille faire quelque chose de plus complexe avec son makefile si ce n'est pas aujourd'hui puis bientôt. –