Comprobar si existe un programa desde un Makefile

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 muy bien 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 estoy lanzando un error, pero podrías hacer algo más útil si quisieras.

Si la variable está disponible, "command-v" realiza la operación económica de imprimir la ruta de 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.

Use la función shell 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 a shell. Para evitar el potencial mensaje "comando no encontrado", redirija el error estándar a /dev/null.

Entonces usted puede comprobar el resultado usando 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 bono, la salida (como la versión del programa) podría ser útil en otras partes de su Makefile.

Mi solución implica un pequeño script de ayuda¹ que coloca un archivo de bandera si existen todos los comandos necesarios. Esto viene con la ventaja de que la comprobación de los comandos necesarios solo se realiza una vez y no en cada invocación make.

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

¹ Más sobre la técnica command -v se puede encontrar aquí .

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 desea que esto sea más silencioso.

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

Para mí todas las respuestas anteriores están basadas en linux y no funcionan con Windows. Soy nuevo para hacer así que mi enfoque puede no ser 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})        

Resuelto compilando un pequeño programa especial en otro destino makefile, cuyo único propósito es comprobar cualquier cosa en tiempo de ejecución que estaba buscando.

Entonces, llamé a este programa en otro destino makefile.

Era algo como esto si recuerdo correctamente:

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

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

Puede usar comandos construidos bash como type foo o command -v foo, como se muestra a continuación:

SHELL := /bin/bash
all: check

check:
        @type foo

Donde foo es su programa/comando. Redirige a > /dev/null si lo quieres en silencio.