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

Question

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

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

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

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

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

(Tenga en cuenta que esto es un duplicado parcial de Dónde agregar un CFLAG, como -std = gnu99, en un proyecto de autotools (Eclipse CDT) ya que estaba obteniendo respuestas específicas de Eclipse que no quería).

La respuesta de @DevSolar no ha ayudado todavía. Un archivo configure.ac (a continuación) genera el script de 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

$ 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''

Answer 1

Aunque el uso de una macro como AC_PROG_CC_STDC es preferible a agregar opciones de compilador a CFLAGS, autoconf actualmente no tiene macros que permitan el soporte del compilador C11; no hay AC_PROG_CC_C11 todavía, y AC_PROG_CC_STDC solo agrega la opción -std=gnu99 para gcc en lugar de o -std=c11 .

Puedes agregar banderas del compilador simplemente poniendo

CFLAGS+=" -std=c11"

En el configure.ac.

Alternativamente, podría ser mejor verificar primero si el compilador soporta la opción agregada, e imprimir una advertencia de lo contrario, indicando al usuario que agregue manualmente una opción equivalente a CFLAGS que funcione para 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 utiliza las macros AX_CHECK_COMPILE_FLAG y AX_APPEND_FLAG encuentran en el archivo GNU Autoconf . Para usarlos, colóquelos en un subdirectorio m4 y agregue AC_CONFIG_MACRO_DIR([m4]) a configure.ac

Answer 2

Este tema se trata en el manual de Automake, Ordenamiento de variables de bandera 27.6 . Existe una interacción entre configure.ac y Makefile.am , y es algo más que establecer una variable de shell conocida en reglas de creación implícitas.

En pocas palabras, deberías configurarlo en una nueva variable llamada algo como mumble_CFLAGS explica 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 adelante, cuando se cree su makefile, la receta para 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 adelante, cuando se genere el makefile, tendrá una receta similar a la siguiente, donde $(MY_PROG_CFLAGS) se aplica a todos los objetos que construyen my_prog :

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

Las my_prog_CFLAGS adicionales de my_prog_CFLAGS te permiten tener múltiples my_prog_CFLAGS 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 del manual de Automake :

Compilar variables de bandera

Esta sección intenta responder a todas las preguntas anteriores. Discutiremos sobre todo CPPFLAGS en nuestros ejemplos, pero en realidad la respuesta es válida para todos los indicadores de compilación utilizados en Automake: CCASFLAGS, CFLAGS, CPPFLAGS, CXXFLAGS, FCFLAGS, FFLAGS, GCJFLAGSPasosJuzgamiento de las partes de la empresa. , y YFLAGS.

CPPFLAGS, AM_CPPFLAGS y mumble_CPPFLAGS son tres variables que se pueden usar para pasar indicadores al preprocesador de C (en realidad, estas variables también se usan para otros lenguajes como C ++ o Fortran preprocesado). CPPFLAGS es la variable de usuario (ver Variables de usuario), AM_CPPFLAGS es la variable Automake y mumble_CPPFLAGS es la variable específica del objetivo de mumble (llamamos a esto una variable por objetivo, consulte Variables de programa y biblioteca).

Automake siempre usa dos de estas variables cuando compila archivos de código fuente. Al compilar un archivo de objeto para el objetivo de mumble, la primera variable será mumble_CPPFLAGS si está definida, o AM_CPPFLAGS de lo 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 se compilará con ''$ (foo_CPPFLAGS) $ (CPPFLAGS)'', (porque xyz.o es parte del objetivo foo), mientras que main.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 es lo suficientemente clara, concentré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, se documenta al final de la salida de ''configure --help''.

Por ejemplo, alguien que necesite agregar / home / my / usr / include a la ruta de búsqueda del compilador de C configurará un paquete con

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

y esta bandera se propagaría a las reglas de compilación de todos los Makefiles.

Answer 3

autoconf tiene una macro para esto:

Sólo hay que poner:

AC_PROG_CC_STDC

Después de tu AC_PROG_CC y todo estará bien.

Especialmente cuando usas otros compiladores que no tienen -std=gnu99 pero operan en modo C99 de manera predeterminada (o tienen una opción diferente como hpcc''s -AC99 a la mente).

NO usaría CFLAGS para ese tipo de cosas.

De la 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''.