web-dev-qa-db-fra.com

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

J'ai un projet simple Autotools C (pas C++).

Les CFLAG (par inspection) semblent être -g -O2.

Je souhaite que tous les fichiers de création générés aient aussi -std=gnu99 ajouté aux CFLAG, car j’utilise for (int i = 0; i < MAX; i++) et similaire.

Je peux évidemment pirater le Makefile, mais cela est écrasé sur ./configure.

Où est le bon endroit pour ajouter (ou changer) les CFLAG requis par le code (par opposition aux CFLAG que l'utilisateur pourrait vouloir modifier)?

(Notez que ceci est une copie partielle de Où ajouter un CFLAG, tel que -std = gnu99, dans un projet autotools (Eclipse CDT) alors que j'obtenais des réponses spécifiques à Eclipse que je ne souhaitais pas.)

La réponse de @ DevSolar n'a pas encore aidé. Un fichier configure.ac (ci-dessous) génère le script configure (également ci-dessous).

configure.ac:

dnl Process this file with autoconf to produce a configure script.

CFLAGS="$CFLAGS -std=gnu99"
AC_PREREQ(2.59)
AC_INIT(tuntest, 1.0)


AC_CANONICAL_SYSTEM
AM_INIT_AUTOMAKE()

AC_PROG_CC

AC_CONFIG_FILES(Makefile src/Makefile)
AC_OUTPUT

$ grep CFLAGS configure

CFLAGS
CFLAGS
To assign environment variables (e.g., CC, CFLAGS...), specify them as
  CFLAGS      C compiler flags
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
ac_test_CFLAGS=${CFLAGS+set}
ac_save_CFLAGS=$CFLAGS
   CFLAGS="-g"
  CFLAGS=""
     CFLAGS="-g"
if test "$ac_test_CFLAGS" = set; then
  CFLAGS=$ac_save_CFLAGS
    CFLAGS="-g -O2"
    CFLAGS="-g"
    CFLAGS="-O2"
    CFLAGS=
ac_compile='$CC -c $CFLAGS $CPPFLAGS conftest.$ac_ext >&5'
ac_link='$CC -o conftest$ac_exeext $CFLAGS $CPPFLAGS $LDFLAGS conftest.$ac_ext $LIBS >&5'
cautotools
23
fadedbee

autoconf a une macro pour cela:

Il suffit de mettre:

AC_PROG_CC_STDC

après votre AC_PROG_CC et tout ira bien.

Surtout lorsque vous utilisez d'autres compilateurs qui n'ont pas -std=gnu99 mais fonctionnent en mode C99 par défaut (ou avez une option différente, le -AC99 de hpcc vous vient à l'esprit).

Je voudraisPASutiliser CFLAGS pour ce genre de chose.

De la docs :

- Macro: AC_PROG_CC_STDC 
 Si le compilateur C ne peut pas compiler la norme ISO C (actuellement C99), 
 Essayez d'ajouter une option à la variable de sortie «CC» pour la faire fonctionner. Si 
 Le compilateur ne prend pas en charge C99, revenez à ANSI 
 C89 (ISO C90). 
 
 Après avoir appelé cette macro, vous pouvez vérifier si le compilateur C 
 a été configuré pour accepter la norme C; sinon, la variable Shell 
 «ac_cv_prog_cc_stdc» est définie sur «non».
26
hroptatyr

Bien que l’utilisation d’une macro telle que AC_PROG_CC_STDC soit préférable à l’ajout d’options de compilation à CFLAGS, autoconf n’a actuellement aucune macros permettant le support du compilateur C11 - il n’existe pas encore de AC_PROG_CC_C11 et AC_PROG_CC_STDC n’ajoute que l’option -std=gnu99 pour gcc au lieu de -std=gnu11 ou -std=c11.

Vous pouvez ajouter des indicateurs de compilateur simplement en mettant

CFLAGS+=" -std=c11"

dans le configure.ac.

Sinon, il serait peut-être préférable de vérifier d'abord si le compilateur prend en charge l'option ajoutée et d'afficher un avertissement sinon, en demandant à 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.])
])

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

1
dpi

Ce sujet est traité dans le manuel Automake, 27.6 Classement des variables d'indicateur . Il existe une interaction entre configure.ac et Makefile.am, et il ne suffit pas de définir une variable Shell bien connue utilisée dans les règles de création implicites.

Bref, vous devriez la définir dans une nouvelle variable appelée quelque chose comme mumble_CFLAGS, décrite dans le manuel Automake. mumble n'est que le nom de votre programme et il est souvent foo ou bar dans d'autres exemples. Plus tard, lorsque votre fichier Make sera créé, la recette de votre programme (mumble ou foo ou bar) utilisera $(mumble_CFLAGS) $(CFLAGS) pour construire la cible.

Voici un exemple de ce à quoi cela pourrait ressembler. Au lieu d'utiliser mumble ou foo ou bar, il utilise my_prog comme nom d'artefact.

configure.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.am:

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

Plus tard, lorsque le makefile sera généré, il aura une recette semblable à celle-ci, où $(MY_PROG_CFLAGS) est appliqué à tous les objets qui construisent my_prog:

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

Les indirections supplémentaires de my_prog_CFLAGS vous permettent d’avoir plusieurs drapeaux pour différentes cibles. Par exemple, vous pourriez avoir un my_prog_CFLAGS, un my_archive_CFLAGS et un my_sharedobj_CFLAGS.

Et ce n'est pas limité à my_prog_CFLAGS. Vous pouvez également avoir my_prog_CPPFLAGS, my_prog_CXXFLAGS et d'autres variables utilisées implicitement dans les makefiles.

Ceci est tiré du Manuel Automake :

Compiler les variables d'indicateur

Cette section tente de répondre à toutes les questions ci-dessus. Nous allons Discuter principalement de CPPFLAGS dans nos exemples, mais en réalité, la réponse est Pour tous les indicateurs de compilation utilisés dans Automake: CCASFLAGS, CFLAGS, CPPFLAGS, CXXFLAGS, FCFLAGS, FFLAGS, FFLAGS, GCJFLAGS, LDFLAGS, LFLAGS, LIBTOOLFLAGS, OBJCFLAGS, OBJCXXFLAGS, RFLAGS, UPCFLAGS et YFLAGS.

CPPFLAGS, AM_CPPFLAGS et mumble_CPPFLAGS sont trois variables que Peut être utilisé pour passer des indicateurs au préprocesseur C (en fait, ces variables Sont également utilisées pour d'autres langages tels que C++ ou Préprocessus [Fort. ). CPPFLAGS est la variable utilisateur (voir Variables utilisateur), AM_CPPFLAGS est la variable Automake et mumble_CPPFLAGS est la variable Spécifique à la cible mumble (nous l'appelons une cible par cible . variable, voir Variables de programme et de bibliothèque).

Automake utilise toujours deux de ces variables lors de la compilation de fichiers sources C . Lors de la compilation d'un fichier objet pour la cible mumble, la première variable Sera mumble_CPPFLAGS si elle est définie, ou AM_CPPFLAGS Sinon. 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)' '(car xyz.o fait partie de la cible foo), tandis que main.o sera compilé avec ' $ (AM_CPPFLAGS) $ (CPPFLAGS) '(car il n'y a pas de variable par cible Pour la barre cible).

La différence entre mumble_CPPFLAGS et AM_CPPFLAGS étant suffisamment claire , Concentrons-nous sur CPPFLAGS. CPPFLAGS est une variable utilisateur, c’est-à-dire une variable Que les utilisateurs ont le droit de modifier pour compiler le package . Cette variable, comme beaucoup d’autres, est documentée à la fin de Du résultat de ‘configure --help’.

Par exemple, une personne qui a besoin d’ajouter/home/mon/usr/include au chemin de recherche du compilateur C Configurera un paquet avec

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

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

0
jww