Come definire le funzioni globali della shell in un Makefile?

Question

voglio definire una funzione di shell

#!/bin/sh 

test() 
{ 
    do_some_complicated_tests $1 $2; 
    if something; then 
    build_thisway $1 $2; 
    else 
    build_otherway $1 $2; 
    fi 
} 

in modo tale che posso usarlo in ogni regola della mia Makefile, come ad esempio:

foo: bar 
    test foo baz 

Per essere chiari, io voglio il guscio funzione per far parte del Makefile. Qual è il modo più elegante per farlo? Punti bonus se puoi farlo senza chiamare ricorsivamente.

---

Background: Il mio problema reale è che make -n produce un'uscita molto lunga e illeggibile. Ogni regola utilizza quasi la stessa sequenza di comandi di shell non leggibili e ci sono molte regole. La soluzione di cui sopra renderebbe più utile l'output di make -n.

Answer 1

Questa soluzione non si basa su un file temporaneo esterno e non ti costringe ad armeggiare con la variabile SHELL.

TESTTOOL=sh -c '\ 
    do_some_complicated_tests $$1 $$2; \ 
    if something; then 
    build_thisway $$1 $$2; 
    else 
    build_otherway $$1 $$2; 
    fi' TESTTOOL 

ifneq (,$(findstring n,$(MAKEFLAGS))) 
TESTTOOL=: TESTTOOL 
endif 

foo: bar 
    ${TESTTOOL} foo baz 

I controlli ifneq…endif blocchi per la bandiera -n sulla riga di comando e imposta l'espansione di TESTTOOL a : TESTTOOL che è facile da leggere e sicuro da eseguire.

La soluzione migliore potrebbe essere trasformare la funzione shell in un programma effettivo se questa è un'opzione per voi.

Answer 2

Qualcosa mi dice che sarebbe meglio filtrare l'output di make -n, ma ciò che si chiede è possibile:

define test 
    @echo do some tests with $(1) and $(2); \ 
    SOMETHING=$(1)_3 ; \ 
    if [ $$SOMETHING == foo_3 ]; then \ 
    echo build this way $(1) $(2); \ 
    else \ 
    echo build another way $(1) $(2) ; \ 
    fi 
endef 

someTarget: 
    $(call test,foo,bar) 

someOtherTarget: 
    $(call test,baz,quartz) 

Answer 3

Dal momento che la questione è aggiunto gnu-make, si potrebbe essere felici con la soluzione di Beta, ma Penso che la soluzione migliore sia quella di 1) rinominare la funzione diversa da test (evitare nomi come ls e cd); a scopo di discussione, supponiamo di averlo rinominato come foo, 2) semplicemente scrivendo uno script chiamato foo e invocandolo dal Makefile. Se davvero si vuole definire una funzione di shell nel Makefile, basta definire per ogni regola:

F = foo() { \ 
    do_some_complicated_tests $$1 $$2; \ 
    if something; then \ 
    build_thisway $$1 $$2; \ 
    else \ 
    build_otherway $$1 $$2; \ 
    fi \ 
} 

all: bar 
    @$(F); foo baz bar 

Non che è necessario disporre di continuazione di una riga su ogni riga della definizione di foo, e il $ sono tutti scappati così che sono passati alla shell.

Answer 4

Io non credo che questo si qualifica come "elegante", ma sembra di fare ciò che si vuole:

## 
## --- Start of ugly hack 
## 

THIS_FILE := $(lastword $(MAKEFILE_LIST)) 

define shell-functions 
: BEGIN 
    # Shell syntax here 
    f() 
    { 
    echo "Here you define your shell function. This is f(): $@" 
    } 

    g() 
    { 
    echo "Another shell function. This is g(): $@" 
    } 
: END 
endef 

# Generate the file with function declarations for the shell 
$(shell sed -n '/^: BEGIN/,/^: END/p' $(THIS_FILE) > .functions.sh) 

# The -i is necessary to use --init-file 
SHELL := /bin/bash --init-file .functions.sh -i 

## 
## -- End of ugly hack 
## 

all: 
    @f 1 2 3 4 
    @g a b c d 

L'esecuzione di questo produce:

$ make -f hack.mk 
Here you define your shell function. This if f(): 1 2 3 4 
Another shell function. This is g(): a b c d 

eseguendolo con -n produce:

$ make -f hack.mk -n 
f 1 2 3 4 
g a b c d 

Questo si basa sul fatto che le macro definite tra define e endef non vengono interpretati da make finché non vengono effettivamente utilizzati, quindi è possibile utilizzare direttamente la sintassi della shell e non è necessario terminare ogni riga con una barra rovesciata. Ovviamente, bombarderà se chiami la macro shell-functions.

Answer 5

Questo è veramente ghetto, ma qualunque cosa. Io uso zsh, ma sono sicuro che ci sono bash e sh equivalenti.

Makefile:

export ZDOTDIR := ./ 

SHELL := /usr/bin/env zsh 

default: 
    f 

.zshenv, stessa directory Makefile:

f() { echo 'CHECK OUT THIS AWESOME FUNCTION!' } 

La variabile ZDOTDIR rende sguardo zsh nella directory corrente per dotfile. Quindi tieni semplicemente quello che vuoi in .zshenv.

$ make 
f 
CHECK OUT THIS AWESOME FUNCTION! 

Answer 6

TL; DR:

nel makefile:

SHELL=bash 
BASH_FUNC_command%%=() { ... } 
export BASH_FUNC_command%% 

Risposta lunga

che ho fatto qualcosa di simile con bash in un contesto non-fare, che lavora qui .

ho dichiarato le mie funzioni di shell in bash e poi esportati con:

export -f function-name 

Sono poi naturalmente disponibili se la stessa shell viene invocata come un sub-processo, nel tuo caso, dal trucco.

Esempio:

$ # define the function 
$ something() { echo do something here ; } 
$ export -f something 

$ # the Makefile 
$ cat > Makefile <<END 
SHELL=bash 
all: ; something 
END 
$ 

Prova ora

$ make 
something 
do something here 
$ 

Come funziona questo sguardo nell'ambiente?

$ env | grep something 
BASH_FUNC_something%%=() { echo do something here 

Quindi la domanda per voi sarebbe come impostare le variabili di ambiente all'interno del Makefile. Il modello sembra essere BASH_FUNC_ nome-funzione %% =() {funzione-corpo}

direttamente all'interno make

Così come fa questo lavoro per voi? Prova questo makefile

SHELL=bash 
define BASH_FUNC_something-else%% 
() { 
    echo something else 
} 
endef 
export BASH_FUNC_something-else%% 

all: ; something-else 

e provarlo:

$ make 
something-else 
something else 

E 'un po' brutto nel Makefile, ma non presenta alcuna bruttura per fare qualcosa -n