Pasando variables adicionales desde la línea de comando para hacer

¿Puedo pasar variables a un archivo Make de GNU como argumentos de línea de comandos? En otras palabras, quiero pasar algunos argumentos que eventualmente se convertirán en variables en el Makefile.

Tiene varias opciones para configurar variables desde fuera de su archivo MAKE:

• Desde el entorno : cada variable de entorno se transforma en una variable de archivo MAKE con el mismo nombre y valor.

  También es posible que desee establecer la -eopción (aka --environments-override) activada , y sus variables de entorno anularán las asignaciones realizadas en el archivo MAKE (a menos que estas asignaciones usen la overridedirectiva . Sin embargo, no es recomendable, y es mucho mejor y flexible usar la ?=asignación (la variable condicional operador de asignación, solo tiene efecto si la variable aún no está definida):

  FOO?=default_value_if_not_set_in_environment
  

  Tenga en cuenta que ciertas variables no se heredan del entorno:

  • MAKE se obtiene del nombre del guión
  • SHELLse establece dentro de un archivo MAKE o se establece de manera predeterminada /bin/sh(justificación: los comandos se especifican dentro del archivo MAKE y son específicos del shell).

• Desde la línea de comando : makepuede tomar asignaciones variables como parte de su línea de comando, mezcladas con objetivos:

  make target FOO=bar
  

  Pero entonces todas las asignaciones a FOOvariables dentro del archivo MAKE serán ignoradas a menos que use la overridedirectiva en la asignación. (El efecto es el mismo que con la -eopción para las variables de entorno).

• Exportar desde el Make primario : si llama a Make desde un Makefile, por lo general no debería escribir explícitamente asignaciones de variables como esta:

  # Don't do this!
  target:
          $(MAKE) -C target CC=$(CC) CFLAGS=$(CFLAGS)
  

  En cambio, la mejor solución podría ser exportar estas variables. La exportación de una variable lo convierte en el entorno de cada invocación de shell, y Realizar llamadas desde estos comandos selecciona estas variables de entorno como se especifica anteriormente.

  # Do like this
  CFLAGS=-g
  export CFLAGS
  target:
          $(MAKE) -C target
  

  También puede exportar todas las variables utilizando exportsin argumentos.

La forma más simple es:

make foo=bar target

Luego, en su archivo MAKE puede consultar $(foo). Tenga en cuenta que esto no se propagará a sub-marcas automáticamente.

Si está utilizando sub-marcas, vea este artículo: Comunicación de variables a una sub-marca

Digamos que tienes un makefile como este:

action:
    echo argument is $(argument)

Entonces lo llamarías make action argument=something

Del manual :

Las variables en make pueden provenir del entorno en el que se ejecuta make. Cada variable de entorno que hace ver cuando se inicia se transforma en una variable de creación con el mismo nombre y valor. Sin embargo, una asignación explícita en el archivo MAKE, o con un argumento de comando, anula el entorno.

Entonces puedes hacer (desde bash):

FOOBAR=1 make

resultando en una variable FOOBARen su Makefile.

Hay otra opción no citada aquí que está incluida en el libro Make de GNU de Stallman y McGrath (ver http://www.chemie.fu-berlin.de/chemnet/use/info/make/make_7.html ). Proporciona el ejemplo:

archive.a: ...
ifneq (,$(findstring t,$(MAKEFLAGS)))
        +touch archive.a
        +ranlib -t archive.a
else
        ranlib archive.a
endif

Implica verificar si un parámetro dado aparece en MAKEFLAGS. Por ejemplo ... suponga que está estudiando sobre subprocesos en c ++ 11 y ha dividido su estudio en varios archivos ( class01, ..., classNM) y desea: compilar todo y ejecutarlo individualmente o compilar uno a la vez tiempo y ejecútelo si se especifica un indicador ( -rpor ejemplo). Entonces, podrías llegar a lo siguiente Makefile:

CXX=clang++-3.5
CXXFLAGS = -Wall -Werror -std=c++11
LDLIBS = -lpthread

SOURCES = class01 class02 class03

%: %.cxx
    $(CXX) $(CXXFLAGS) -o $@.out $^ $(LDLIBS)
ifneq (,$(findstring r,  $(MAKEFLAGS)))
    ./$@.out
endif

all: $(SOURCES)

.PHONY: clean

clean:
    find . -name "*.out" -delete

Teniendo eso, usted:

• construir y ejecutar un archivo w / make -r class02;
• construir todo w / makeor make all;
• compila y ejecuta todos los w / make -r(supongamos que todos ellos contienen cierto tipo de afirmación y solo quieres probarlos todos)

parece

comando args sobrescribir variable de entorno

Makefile

send:
    echo $(MESSAGE1) $(MESSAGE2)

Ejecutar ejemplo

$ MESSAGE1=YES MESSAGE2=NG  make send MESSAGE2=OK
echo YES OK
YES OK

Si crea un archivo llamado Makefile y agrega una variable como esta $ (unittest), entonces podrá usar esta variable dentro del Makefile incluso con comodines

ejemplo:

make unittest=*

Uso BOOST_TEST y al asignar un comodín al parámetro --run_test = $ (unittest), podré usar expresiones regulares para filtrar la prueba que quiero que ejecute mi Makefile

export ROOT_DIR=<path/value>

Luego use la variable, $(ROOT_DIR)en el Makefile.