Vérifier si un programme existe à partir d'un Makefile

Comment puis-je vérifier si un programme peut être appelé à partir d'un Makefile?

(Autrement dit, le programme doit exister dans le chemin ou être appelable d'une autre manière.)

Il pourrait être utilisé pour vérifier pour quel compilateur est installé, par exemple.

Par exemple, quelque chose comme cette question , mais sans supposer que le shell sous-jacent est compatible POSIX.

Parfois, vous avez besoin d'un Makefile pour pouvoir s'exécuter sur différents OS cibles et vous voulez que la construction échoue tôt si un exécutable requis n'est pas dans PATHplutôt que de s'exécuter pendant une période éventuellement longue avant d'échouer.

L'excellente solution fournie par engineerchuan nécessite de faire une cible . Cependant, si vous avez de nombreux exécutables à tester et que votre Makefile a de nombreuses cibles indépendantes, dont chacune nécessite les tests, alors chaque cible nécessite la cible de test en tant que dépendance. Cela entraîne beaucoup de frappe supplémentaire ainsi que du temps de traitement lorsque vous créez plus d'une cible à la fois.

La solution fournie par 0xf peut tester un exécutable sans faire de cible. Cela économise beaucoup de temps de frappe et d'exécution lorsqu'il y a plusieurs cibles qui peuvent être construites séparément ou ensemble.

Mon amélioration de cette dernière solution est d'utiliser l' whichexécutable ( wheresous Windows), plutôt que de compter sur l'existence d'une --versionoption dans chaque exécutable, directement dans la ifeqdirective GNU Make , plutôt que de définir une nouvelle variable, et d'utiliser le GNU Make errorpour arrêter la construction si un exécutable requis n'est pas dans ${PATH}. Par exemple, pour tester l' lzopexécutable:

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

Si vous avez plusieurs exécutables à vérifier, vous pouvez utiliser une foreachfonction avec l' whichexécutable:

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

Notez l'utilisation de l' :=opérateur d'affectation qui est requis pour forcer l'évaluation immédiate de l'expression RHS. Si votre Makefile change le PATH, alors au lieu de la dernière ligne ci-dessus, vous aurez besoin de:

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

Cela devrait vous donner une sortie similaire à:

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

J'ai mélangé les solutions de @kenorb et @ 0xF et j'ai obtenu ceci:

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 

Cela fonctionne à merveille car "commande -v" n'affiche rien si l'exécutable n'est pas disponible, donc la variable DOT n'est jamais définie et vous pouvez simplement la vérifier quand vous le souhaitez dans votre code. Dans cet exemple, je lance une erreur, mais vous pouvez faire quelque chose de plus utile si vous le souhaitez.

Si la variable est disponible, "commande -v" effectue l'opération peu coûteuse d'impression du chemin de commande, définissant la variable DOT.

C'est ce que tu as fait?

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

crédit à mon collègue.

Utilisez la shellfonction pour appeler votre programme de manière à ce qu'il imprime quelque chose sur la sortie standard. Par exemple, passez--version .

GNU Make ignore l'état de sortie de la commande passée à shell. Pour éviter le message potentiel «commande introuvable», redirigez l'erreur standard vers/dev/null .

Ensuite , vous pouvez vérifier le résultat en utilisant 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

En prime, la sortie (telle que la version du programme) peut être utile dans d'autres parties de votre Makefile.

Nettoyé certaines des solutions existantes ici ...

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

le $(info ...) vous pouvez exclure si vous voulez que ce soit plus calme.

Cela échouera rapidement . Aucune cible requise.

Ma solution implique un petit script d'aide ¹ qui place un fichier indicateur si toutes les commandes requises existent. Cela présente l'avantage que la vérification des commandes requises n'est effectuée qu'une seule fois et non toutes lesmake appel.

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

¹ Pour en savoir plus sur la command -vtechnique, cliquez ici .

Pour moi, toutes les réponses ci-dessus sont basées sur Linux et ne fonctionnent pas avec Windows. Je suis nouveau à faire, donc mon approche n'est peut-être pas idéale. Mais un exemple complet qui fonctionne pour moi à la fois sous Linux et Windows est le suivant:

# 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

éventuellement lorsque j'ai besoin de détecter plus d'outils que je peux utiliser:

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

Vous pouvez utiliser des commandes intégrées bash telles que type fooou command -v foo, comme ci-dessous:

SHELL := /bin/bash
all: check

check:
        @type foo

Où fooest votre programme / commande. Redirigez vers > /dev/nullsi vous le souhaitez silencieux.

Supposons que vous ayez des cibles et des constructeurs différents, chacun nécessitant un autre ensemble d'outils. Définissez une liste de ces outils et considérez-les comme une cible pour forcer la vérification de leur disponibilité

Par exemple:

make_tools := gcc md5sum gzip

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

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

Je définis personnellement un requireobjectif qui passe avant tous les autres. Cette cible exécute simplement les commandes de version de toutes les exigences une par une et imprime les messages d'erreur appropriés si la commande n'est pas valide.

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 sortie du script ci-dessous est

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

Résolu en compilant un petit programme spécial dans une autre cible de makefile, dont le seul but est de vérifier les éléments d'exécution que je recherchais.

Ensuite, j'ai appelé ce programme dans une autre cible de makefile.

C'était quelque chose comme ça si je me souviens bien:

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

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

Les solutions vérifiant la STDERRsortie de --versionne fonctionnent pas pour les programmes qui impriment leur version à la STDOUTplace de STDERR. Au lieu de vérifier leur sortie vers STDERRou STDOUT, vérifiez le code de retour du programme. Si le programme n'existe pas, son code de sortie sera toujours différent de zéro.

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