Controlla se esiste un programma da un Makefile

Come posso verificare se un programma è richiamabile da un Makefile?

(Cioè, il programma dovrebbe esistere nel percorso o altrimenti essere richiamabile.)

Potrebbe essere usato per verificare quale compilatore è installato, ad esempio.

Ad esempio, qualcosa di simile a questa domanda , ma senza presumere che la shell sottostante sia compatibile con POSIX.

A volte è necessario un Makefile per essere in grado di funzionare su diversi sistemi operativi di destinazione e si desidera che la compilazione fallisca in anticipo se un eseguibile richiesto non è presente PATHpiuttosto che eseguire per un tempo possibilmente lungo prima di fallire.

L'eccellente soluzione fornita da engineerchuan richiede la creazione di un obiettivo . Tuttavia, se hai molti eseguibili da testare e il tuo Makefile ha molti target indipendenti, ognuno dei quali richiede i test, allora ogni target richiede il target di test come dipendenza. Ciò rende molto più digitazione e tempo di elaborazione quando crei più di un obiettivo alla volta.

La soluzione fornita da 0xf può testare un eseguibile senza creare una destinazione. Ciò consente di risparmiare molto tempo di digitazione e di esecuzione quando ci sono più target che possono essere costruiti separatamente o insieme.

Il mio miglioramento a quest'ultima soluzione consiste nell'usare l' whicheseguibile ( wherein Windows), piuttosto che fare affidamento sul fatto che ci sia --versionun'opzione in ogni eseguibile, direttamente nella ifeqdirettiva GNU Make , piuttosto che definire una nuova variabile e usare GNU Make errorfunzione per interrompere la compilazione se un eseguibile richiesto non è presente ${PATH}. Ad esempio, per verificare l' lzopeseguibile:

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

Se devi controllare diversi eseguibili, potresti voler utilizzare una foreachfunzione con l' whicheseguibile:

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

Notare l'uso :=dell'operatore di assegnazione necessario per forzare la valutazione immediata dell'espressione RHS. Se il tuo Makefile cambia il PATH, allora invece dell'ultima riga sopra avrai bisogno di:

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

Questo dovrebbe darti un output simile a:

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

Ho mescolato le soluzioni di @kenorb e @ 0xF e ho ottenuto questo:

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 

Funziona magnificamente perché "comando -v" non stampa nulla se l'eseguibile non è disponibile, quindi la variabile DOT non viene mai definita e puoi semplicemente controllarla ogni volta che vuoi nel tuo codice. In questo esempio sto lanciando un errore, ma potresti fare qualcosa di più utile se lo desideri.

Se la variabile è disponibile, "comando -v" esegue l'operazione economica di stampare il percorso del comando, definendo la variabile DOT.

è questo quello che hai fatto?

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

credito al mio collega.

Usa la shellfunzione per chiamare il tuo programma in modo che stampi qualcosa sullo standard output. Ad esempio, passa --version.

GNU Make ignora lo stato di uscita del comando passato a shell. Per evitare il potenziale messaggio "comando non trovato", reindirizzare l'errore standard a /dev/null.

Poi si può verificare il risultato utilizzando 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

Come bonus, l'output (come la versione del programma) potrebbe essere utile in altre parti del tuo Makefile.

Ripulito alcune delle soluzioni esistenti qui ...

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

La $(info ...)si può escludere, se si desidera che questo sia più tranquillo.

Questo fallirà velocemente . Nessun obiettivo richiesto.

La mia soluzione prevede un piccolo script di supporto ¹ che inserisce un file flag se esistono tutti i comandi richiesti. Ciò ha il vantaggio che il controllo dei comandi richiesti viene eseguito solo una volta e non a ogni makechiamata.

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

¹ Ulteriori informazioni sulla command -vtecnica possono essere trovate qui .

Per me tutte le risposte di cui sopra sono basate su Linux e non funzionano con Windows. Sono nuovo, quindi il mio approccio potrebbe non essere l'ideale. Ma l'esempio completo che funziona per me sia su Linux che su Windows è questo:

# 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

opzionalmente quando ho bisogno di rilevare più strumenti che posso usare:

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

Puoi usare comandi costruiti bash come type fooo command -v foo, come di seguito:

SHELL := /bin/bash
all: check

check:
        @type foo

Dov'è il footuo programma / comando. Reindirizza a > /dev/nullse vuoi che sia silenzioso.

Supponiamo di avere obiettivi e costruttori diversi, ognuno richiede un altro set di strumenti. Impostare un elenco di tali strumenti e considerarli come obiettivi per forzare il controllo della loro disponibilità

Per esempio:

make_tools := gcc md5sum gzip

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

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

Definisco personalmente un requireobiettivo che corre prima di tutti gli altri. Questa destinazione esegue semplicemente i comandi di versione di tutti i requisiti uno alla volta e stampa i messaggi di errore appropriati se il comando non è valido.

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.

L'output dello script seguente è

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

Risolto compilando un programmino speciale in un altro target di makefile, il cui unico scopo è quello di controllare qualsiasi cosa di runtime stavo cercando.

Quindi, ho chiamato questo programma in un altro target del makefile.

Se ricordo bene, era qualcosa del genere:

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

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

Le soluzioni che controllano l' STDERRoutput di --versionnon funzionano per i programmi che stampano la loro versione STDOUTinvece di STDERR. Invece di controllare il loro output su STDERRo STDOUT, controlla il codice di ritorno del programma. Se il programma non esiste, il suo codice di uscita sarà sempre diverso da zero.

#!/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}