Où Ajouter un CFLAG, tel que-std=gnu99, dans un projet autotools

bien que l'utilisation d'une macro comme AC_PROG_CC_STDC soit préférable à l'ajout d'options de compilateur aux CFLAGS, autoconf n'a actuellement pas de macro permettant le support du compilateur C11 -- il n'y a pas encore de AC_PROG_CC_C11 et AC_PROG_CC_STDC ajoute seulement l'option -std=gnu99 pour gcc au lieu de -std=gnu11 ou -std=c11 .

vous pouvez ajouter des options de compilateur simplement en mettant

CFLAGS+=" -std=c11"

dans le configure.ac.

alternativement, il peut-être serait-il préférable de vérifier d'abord si le compilateur supporte l'option ajoutée, et d'imprimer un avertissement sinon, en disant à l'utilisateur d'ajouter manuellement une option équivalente à CFLAGS qui fonctionne pour son compilateur:

AX_CHECK_COMPILE_FLAG([-std=c11],
  [AX_APPEND_FLAG([-std=c11])],
  [AC_MSG_WARN([-std=c11 not supported, you may have to set CFLAGS to enable C11 support.])
])

utilise les macros AX_CHECK_COMPILE_FLAG et AX_APPEND_FLAG trouvées dans GNU Autoconf Archive . Pour les utiliser, Mettez-les dans un sous-répertoire m4 et ajoutez AC_CONFIG_MACRO_DIR([m4]) à configurer.ac

ce sujet est couvert dans le manuel D'Automake, 27.6 variables de drapeau ordonnant . Il y a une interaction entre configure.ac et Makefile.am , et il ne s'agit pas seulement de définir une variable shell bien connue utilisée dans les règles de make implicites.

Le court, vous devez définir une nouvelle variable appelée quelque chose comme mumble_CFLAGS discuté dans le Automake manuel. mumble est juste le nom de votre programme, et il est souvent foo ou bar dans d'autres exemples. Plus tard, lorsque votre makefile sera créé, la recette de votre programme ( mumble ou foo ou bar ) utilisera $(mumble_CFLAGS) $(CFLAGS) pour construire la cible.

voici un exemple de comment il pourrait ressembler. Au lieu d'utiliser mumble ou foo ou bar , il utilise my_prog comme nom d'artefact.

configurer.ac :

# Perform a compile test using -std=gnu99, set has_gnu99
if test "$has_gnu99" -eq "1"; then
  AC_SUBST([MY_GNU99], [-std=gnu99])
fi

Makefile.suis :

bin_PROGRAMS = my_prog
my_prog_CFLAGS = $(MY_GNU99) $(MY_ANOTHER_FLAG) $(MY_YET_ANOTHER_FLAG) ...

plus tard, lorsque le makefile est généré, il aura une recette similaire à la suivante, où $(MY_PROG_CFLAGS) est appliqué à tous les objets qui construisent my_prog :

my_prog :
    $(CC) $(CPPFLAGS) $(MY_PROG_CFLAGS) $(CFLAGS) -c $< -o $@

les options supplémentaires de my_prog_CFLAGS vous permettent d'avoir plusieurs options pour différentes cibles. Par exemple, vous pourriez avoir une my_prog_CFLAGS , a my_archive_CFLAGS et a my_sharedobj_CFLAGS .

et son non limité à my_prog_CFLAGS . Vous pouvez aussi avoir my_prog_CPPFLAGS , my_prog_CXXFLAGS et d'autres variables utilisées implicitement dans les makefiles.

---

C'est du manuel D'Automake :

Compiler Les Variables De Drapeau

cette section tente de répondre à toutes les questions ci-dessus. Nous allons la plupart du temps discuter CPPFLAGS dans nos exemples, mais en fait la réponse tient pour toutes les options de compilation utilisées dans Automake: CCASFLAGS, CFLAGS, CPPFLAGS, CXXFLAGS, FCFLAGS, FFLAGS, GCJFLAGS, LDFLAGS, LFLAGS, LIBTOOLFLAGS, OBJCFLAGS, OBJCXXFLAGS, RFLAGS, UPCFLAGS, and YFLAGS.

CPPFLAGS, AM_CPPFLAGS, et mumble_CPPFLAGS sont trois variables qui peut être utilisé pour passer des drapeaux au C préprocesseur (en fait ces les variables sont également utilisés pour d'autres langages comme C++ ou prétraitées Fortran). CPPFLAGS est la variable de l'utilisateur (Voir Variables de l'utilisateur), AM_CPPFLAGS est la variable Automake, et mumble_CPPFLAGS est la variable spécifique à la cible de mumble (nous appelons cela une cible par cible) variable, voir Variables de programme et de bibliothèque).

Automake utilise toujours deux de ces variables lors de la compilation des sources C fichier. Lors de la compilation d'un fichier objet pour mumble target, le premier la variable sera mumble_CPPFLAGS si elle est définie, ou AM_CPPFLAGS autrement. La deuxième variable est toujours CPPFLAGS.

dans l'exemple suivant,

bin_PROGRAMS = foo bar
foo_SOURCES = xyz.c
bar_SOURCES = main.c
foo_CPPFLAGS = -DFOO
AM_CPPFLAGS = -DBAZ

xyz.o sera compilé avec ' $(foo_CPPFLAGS) $(CPPFLAGS)’, (parce que xyz.o fait partie de la cible foo), alors que main.o sera compilé avec '$(AM_CPPFLAGS) $(CPPFLAGS)’ (parce qu'il n'y a pas de variable par cible) pour la cible de la barre).

la différence entre mumble_CPPFLAGS et AM_CPPFLAGS étant claire assez, concentrons-nous sur les CPPFLAGS. CPPFLAGS est une variable d'utilisateur, i.e., une variable que les utilisateurs ont le droit de modifier afin de compiler paquet. Cette variable, comme beaucoup d'autres, est documentée à la fin de la sortie de ‘configure --help".

Par exemple, quelqu'un qui a besoin d'ajouter /home/mon/usr/include à la C le chemin de recherche du compilateur configurerait un paquet avec

./configure CPPFLAGS='-I /home/my/usr/include'

et ce drapeau serait propagé aux règles de compilation de tous Les Makefiles.