Compruebe si existe un programa a partir de un Makefile

¿Cómo puedo comprobar si se puede llamar a un programa desde un Makefile?

(Es decir, el programa debe existir en la ruta o ser invocable).

Podría usarse para verificar qué compilador está instalado, por ejemplo.

Por ejemplo, algo como esta pregunta , pero sin asumir que el shell subyacente es compatible con POSIX.

A veces, necesita un archivo Makefile para poder ejecutarse en diferentes sistemas operativos de destino y desea que la compilación falle antes si un ejecutable requerido no está en PATHlugar de ejecutarse durante un tiempo posiblemente largo antes de fallar.

La excelente solución proporcionada por Engineerchuan requiere hacer un objetivo . Sin embargo, si tiene muchos ejecutables para probar y su Makefile tiene muchos objetivos independientes, cada uno de los cuales requiere las pruebas, entonces cada objetivo requiere el objetivo de prueba como una dependencia. Eso genera una gran cantidad de escritura adicional, así como tiempo de procesamiento cuando crea más de un objetivo a la vez.

La solución proporcionada por 0xf puede probar un ejecutable sin hacer un objetivo. Eso ahorra mucho tiempo de escritura y ejecución cuando hay varios objetivos que se pueden construir por separado o juntos.

Mi mejora con respecto a la última solución es usar el whichejecutable ( whereen Windows), en lugar de confiar en que haya una --versionopción en cada ejecutable, directamente en la ifeqdirectiva GNU Make , en lugar de definir una nueva variable y usar GNU Make errorfunción para detener la compilación si un ejecutable requerido no está en ${PATH}. Por ejemplo, para probar el lzopejecutable:

 ifeq (, $(shell which lzop))
 $(error "No lzop in $(PATH), consider doing apt-get install lzop")
 endif

Si tiene varios ejecutables para verificar, entonces es posible que desee usar una foreachfunción con el whichejecutable:

EXECUTABLES = ls dd dudu lxop
K := $(foreach exec,$(EXECUTABLES),\
        $(if $(shell which $(exec)),some string,$(error "No $(exec) in PATH")))

Tenga en cuenta el uso del :=operador de asignación que se requiere para forzar la evaluación inmediata de la expresión RHS. Si su Makefile cambia PATH, entonces en lugar de la última línea de arriba necesitará:

        $(if $(shell PATH=$(PATH) which $(exec)),some string,$(error "No $(exec) in PATH")))

Esto debería darle un resultado similar a:

ads$ make
Makefile:5: *** "No dudu in PATH.  Stop.

Mezclé las soluciones de @kenorb y @ 0xF y obtuve esto:

DOT := $(shell command -v dot 2> /dev/null)

all:
ifndef DOT
    $(error "dot is not available please install graphviz")
endif
    dot -Tpdf -o pres.pdf pres.dot 

Funciona de maravilla porque "command -v" no imprime nada si el ejecutable no está disponible, por lo que la variable DOT nunca se define y puede verificarla cuando lo desee en su código. En este ejemplo, arrojo un error, pero podría hacer algo más útil si quisiera.

Si la variable está disponible, "comando -v" realiza la operación económica de imprimir la ruta del comando, definiendo la variable DOT.

¿Es esto lo que hiciste?

check: PYTHON-exists
PYTHON-exists: ; @which python > /dev/null
mytarget: check
.PHONY: check PYTHON-exists

crédito a mi compañero de trabajo.

Utilice la shellfunción para llamar a su programa de manera que imprima algo en la salida estándar. Por ejemplo, pase --version.

GNU Make ignora el estado de salida del comando pasado shell. Para evitar el mensaje potencial "comando no encontrado", redirija el error estándar a /dev/null.

A continuación puede consultar el resultado utilizando ifdef, ifndef, $(if)etc.

YOUR_PROGRAM_VERSION := $(shell your_program --version 2>/dev/null)

all:
ifdef YOUR_PROGRAM_VERSION
    @echo "Found version $(YOUR_PROGRAM_VERSION)"
else
    @echo Not found
endif

Como beneficio adicional, la salida (como la versión del programa) puede ser útil en otras partes de su Makefile.

Limpió algunas de las soluciones existentes aquí ...

REQUIRED_BINS := composer npm node php npm-shrinkwrap
$(foreach bin,$(REQUIRED_BINS),\
    $(if $(shell command -v $(bin) 2> /dev/null),$(info Found `$(bin)`),$(error Please install `$(bin)`)))

El $(info ...)puede excluir si quieres que esto sea más silencioso.

Esto fallará rápidamente . No se requiere objetivo.

Mi solución implica un pequeño script auxiliar ¹ que coloca un archivo de bandera si existen todos los comandos necesarios. Esto tiene la ventaja de que la verificación de los comandos requeridos solo se realiza una vez y no en cada makeinvocación.

check_cmds.sh

#!/bin/bash

NEEDED_COMMANDS="jlex byaccj ant javac"

for cmd in ${NEEDED_COMMANDS} ; do
    if ! command -v ${cmd} &> /dev/null ; then
        echo Please install ${cmd}!
        exit 1
    fi
done

touch .cmd_ok

Makefile

.cmd_ok:
    ./check_cmds.sh

build: .cmd_ok target1 target2

¹command -v Puede encontrar más información sobre la técnica aquí .

Para mí, todas las respuestas anteriores se basan en Linux y no funcionan con Windows. Soy nuevo en hacer, por lo que mi enfoque puede no ser el ideal. Pero el ejemplo completo que funciona para mí tanto en Linux como en Windows es este:

# detect what shell is used
ifeq ($(findstring cmd.exe,$(SHELL)),cmd.exe)
$(info "shell Windows cmd.exe")
DEVNUL := NUL
WHICH := where
else
$(info "shell Bash")
DEVNUL := /dev/null
WHICH := which
endif

# detect platform independently if gcc is installed
ifeq ($(shell ${WHICH} gcc 2>${DEVNUL}),)
$(error "gcc is not in your system PATH")
else
$(info "gcc found")
endif

opcionalmente, cuando necesito detectar más herramientas que puedo usar:

EXECUTABLES = ls dd 
K := $(foreach myTestCommand,$(EXECUTABLES),\
        $(if $(shell ${WHICH} $(myTestCommand) 2>${DEVNUL} ),\
            $(myTestCommand) found,\
            $(error "No $(myTestCommand) in PATH)))
$(info ${K})        

Puede usar comandos integrados en bash como type fooo command -v foo, como se muestra a continuación:

SHELL := /bin/bash
all: check

check:
        @type foo

¿Dónde fooestá tu programa / comando? Redirigir a > /dev/nullsi lo desea en silencio.

Suponga que tiene diferentes objetivos y constructores, cada uno requiere otro conjunto de herramientas. Establezca una lista de tales herramientas y considérelas como objetivo para forzar la verificación de su disponibilidad.

Por ejemplo:

make_tools := gcc md5sum gzip

$(make_tools):  
    @which $@ > /dev/null

file.txt.gz: file.txt gzip
    gzip -c file.txt > file.txt.gz 

Personalmente estoy definiendo un requireobjetivo que se ejecuta antes que todos los demás. Este objetivo simplemente ejecuta los comandos de versión de todos los requisitos uno a la vez e imprime los mensajes de error apropiados si el comando no es válido.

all: require validate test etc

require:
    @echo "Checking the programs required for the build are installed..."
    @shellcheck --version >/dev/null 2>&1 || (echo "ERROR: shellcheck is required."; exit 1)
    @derplerp --version >/dev/null 2>&1 || (echo "ERROR: derplerp is required."; exit 1) 

# And the rest of your makefile below.

La salida del siguiente script es

Checking the programs required for the build are installed...
ERROR: derplerp is required.
makefile:X: recipe for target 'prerequisites' failed
make: *** [prerequisites] Error 1

Resuelto compilando un pequeño programa especial en otro destino de archivo MAKE, cuyo único propósito es verificar cualquier material de tiempo de ejecución que esté buscando.

Luego, llamé a este programa en otro destino de archivo MAKE.

Era algo como esto si no recuerdo mal:

real: checker real.c
    cc -o real real.c `./checker`

checker: checker.c
    cc -o checker checker.c

Las soluciones que comprueban la STDERRsalida de --versionno funcionan para programas que imprimen su versión en STDOUTlugar de STDERR. En lugar de verificar su salida a STDERRo STDOUT, verifique el código de retorno del programa. Si el programa no existe, su código de salida siempre será distinto de cero.

#!/usr/bin/make -f
# /programming/7123241/makefile-as-an-executable-script-with-shebang
ECHOCMD:=/bin/echo -e
SHELL := /bin/bash

RESULT := $(shell python --version >/dev/null 2>&1 || (echo "Your command failed with $$?"))

ifeq (,${RESULT})
    EXISTS := true
else
    EXISTS := false
endif

all:
    echo EXISTS: ${EXISTS}
    echo RESULT: ${RESULT}