Dónde agregar un CFLAG, como -std = gnu99, en un proyecto de autotools

Question

Tengo un proyecto simple Autotools C (no C++).

CFLAG (por inspección) parecen ser -g -O2.

Quiero que todos los archivos make generados también tengan -std=gnu99 anexados a los CFLAG, porque utilizo for (int i = 0; i < MAX; i++) y similares.

Obviamente, puedo hackear el archivo MAKE, pero esto se sobrescribe en ./configure.

¿Dónde está el lugar correcto para agregar (o cambiar) los CFLAG que requiere el código (en lugar de los CFLAG que el usuario podría querer cambiar)?

(Tenga en cuenta que esto es duplicado parcial de Where to add a CFLAG, such as -std=gnu99, into an (Eclipse CDT) autotools project ya que llegaba respuestas Eclipse-específicos que yo no quería.)

---

@ respuesta de DevSolar no ha ayudado todavía. Un archivo configure.ac (a continuación) genera el script configure (también a continuación).

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 

$ CFLAGS grep configurar

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' 

Answer 1

autoconf tiene una macro para esto:

Sólo hay que poner:

AC_PROG_CC_STDC 

después de su AC_PROG_CC y todo estará bien.

Especialmente cuando utiliza otros compiladores que no tienen -std=gnu99 pero operan en modo C99 por defecto (o tienen una opción diferente resortes de hpcc -AC99 en mente).

Yo NO uso CFLAGS para ese tipo de cosas.

Desde el docs:

-- Macro: AC_PROG_CC_STDC 
If the C compiler cannot compile ISO Standard C (currently C99), 
try to add an option to output variable `CC' to make it work. If 
the compiler does not support C99, fall back to supporting ANSI 
C89 (ISO C90). 

After calling this macro you can check whether the C compiler has 
been set to accept Standard C; if not, the shell variable 
`ac_cv_prog_cc_stdc' is set to `no'.

Answer 2

Aunque el uso de una macro como AC_PROG_CC_STDC es preferible añadir opciones del compilador a CFLAGS, autoconf no tiene macros que permiten el apoyo C11 compilador - no hay AC_PROG_CC_C11 sin embargo, y sólo AC_PROG_CC_STDC agrega la opción -std=gnu99 para gcc en lugar de -std=gnu11 o -std=c11.

Puede añadir opciones del compilador simplemente poniendo

CFLAGS+=" -std=c11" 

en el configure.ac.

Alternativamente, podría ser mejor para comprobar primero si el compilador soporta la opción añadida, e imprimir una advertencia de lo contrario, indicando al usuario añadir manualmente una opción equivalente a CFLAGS que trabaja por su compilador:

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.]) 
]) 

Esto usa las macros AX_CHECK_COMPILE_FLAG y AX_APPEND_FLAG que se encuentran en el GNU Autoconf Archive. Para usarlos, colóquelos en un subdirectorio m4 y agregue AC_CONFIG_MACRO_DIR([m4]) para configurar.ac

Answer 3

Este tema se trata en el manual de Automake, 27.6 Flag Variables Ordering. Existe una interacción entre configure.ac y Makefile.am, y es más que simplemente establecer una variable de shell conocida que se usa en las reglas de marca implícitas.

En pocas palabras, debe configurarlo en una nueva variable llamada algo así como mumble_CFLAGS explicada en el manual de Automake. mumble es solo el nombre de su programa, y ​​a menudo es foo o bar en otros ejemplos. Más tarde, cuando se crea su archivo MAKE, la receta de su programa (mumble o foo o bar) usará $(mumble_CFLAGS) $(CFLAGS) para construir el objetivo.

Aquí hay un ejemplo de cómo podría verse. En lugar de usar mumble o foo o bar, usa my_prog como nombre de artefacto.

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) ... 

Más tarde, cuando se genera el archivo MAKE, que tendrá una receta similar a la siguiente, donde $(MY_PROG_CFLAGS) se aplica a todos los objetos que compilan my_prog:

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

Los indirecciones extra de my_prog_CFLAGS le permite tener varios indicadores para diferentes objetivos. Por ejemplo, podría tener un my_prog_CFLAGS, un my_archive_CFLAGS y un my_sharedobj_CFLAGS.

Y no se limita a my_prog_CFLAGS. También podría tener my_prog_CPPFLAGS, my_prog_CXXFLAGS y otras variables utilizadas implícitamente en makefiles.

---

Esto es de la Automake manual:

variables

bandera de compilación

En esta sección se intenta dar respuesta a todas las preguntas anteriores.Vamos a sobre todo discutir CPPFLAGS en nuestros ejemplos, pero en realidad la respuesta sostiene para todas las banderas de compilación utilizados en Automake: CCASFLAGS, CFLAGS, CPPFLAGS, CXXFLAGS, FCFLAGS, fFlags, GCJFLAGS, LDFLAGS, LFLAGS, LIBTOOLFLAGS, OBJCFLAGS, OBJCXXFLAGS , RFLAGS, UPCFLAGS y YFLAGS.

CPPFLAGS, AM_CPPFLAGS y mumble_CPPFLAGS tres variables que se puede utilizar para pasar opciones al preprocesador C (en realidad estos las variables se utilizan también para otros lenguajes como C++ o Fortran preprocesados ​​ ). CPPFLAGS es la variable de usuario (consulte Variables de usuario), AM_CPPFLAGS es la variable Automake y mumble_CPPFLAGS es la variable específica del objetivo silencioso (a esto lo llamamos una variable por destino, consulte Variables de programa y biblioteca).

Automake siempre utiliza dos de estas variables al compilar archivos de fuentes C . Al compilar un archivo de objeto para el objetivo de murmullo, la primera variable será mumble_CPPFLAGS si está definida, o AM_CPPFLAGS en caso contrario. La segunda variable es siempre CPPFLAGS.

En el siguiente ejemplo,

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

xyz.o será compilado con '$ (foo_CPPFLAGS) $ (CPPFLAGS)', (porque xyz.o es parte del objetivo foo), mientras principal .o se compilará con '$ (AM_CPPFLAGS) $ (CPPFLAGS)' (porque no hay una variable por objetivo para la barra de destino).

La diferencia entre mumble_CPPFLAGS y AM_CPPFLAGS siendo claro suficiente, centrémonos en CPPFLAGS. CPPFLAGS es una variable de usuario, es decir, una variable que los usuarios tienen derecho a modificar para compilar el paquete . Esta variable, como muchas otras, está documentada al final de la salida de 'configure --help'.

Por ejemplo, alguien que necesita añadir/home/mi/usr/include a la ruta de búsqueda del C del compilador configurar un paquete con

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

y esta bandera se propagó a las normas de compilación de todos Makefiles.