Liste metas / alvos no GNU make que contêm variáveis ​​em sua definição

Eu tenho um makefile bastante grande que cria vários destinos dinamicamente computando nomes de variáveis. (por exemplo, foo $ (VAR): $ (PREREQS)). Existe alguma maneira de o gnu make ser convencido a cuspir uma lista de alvos depois de expandir essas variáveis?

Eu gostaria de ser capaz de obter os alvos para um makefile arbitrário. Estou tentando escrever uma função de conclusão para meu shell.

Você pode analisar a saída de make -pn(ou seja make --print-data-base --dry-run)? Ele imprime todas as variáveis, regras, regras implícitas e quais comandos serão executados em detalhes trabalhosos.

make -qp | awk -F':' '/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ {split($1,A,/ /);for(i in A)print A[i]}'     

Retirado do complemento make arg, que funciona perfeitamente.

Não tenho certeza se isso é apenas uma coisa gnu make, mas funciona bem:

make help

Vários respondentes sugeriram o uso de make -pn, que imprimirá o banco de dados de regras, mas não executará nada - mais ou menos. O problema com essa abordagem é que -nainda invoca todas as marcas recursivas e ainda faz muito mais trabalho do que o necessário, porque imprime todos os comandos que teria invocado em uma compilação regular. Uma solução mais eficiente seria criar um makefile trivial, dummy.mk, com estes conteúdos:

__all_targets__: ; #no-op

Agora invoque make as make -p -f Makefile -f dummy.mk __all_targets__. Em qualquer construção substancial, a diferença na quantidade de produção gerada pelo make é significativa. Por exemplo:

$ gmake -pn | wc
 138985 2632330 69612711
$ gmake -f Makefile -f /tmp/dummy.mk -pn __all_targets__ | wc
  21673   93437  878985

O tempo de execução também foi dramaticamente melhor - 2.063s para a primeira versão, 0.059s para a segunda.

Confira a conclusão do bash para make no GitHub.

Edit: FYI, o repositório git de conclusão debian bash em outra resposta agora incorpora uma versão aprimorada deste script adaptado para casos de uso de conclusão bash.

#!/bin/bash

SCRIPT='
  /^# Make data base/,/^# Files/d             # skip until files section
  /^# Not a target/,+1          d             # following target isnt
  /^\.PHONY:/                   d             # special target
  /^\.SUFFIXES:/                d             # special target
  /^\.DEFAULT:/                 d             # special target
  /^\.PRECIOUS:/                d             # special target
  /^\.INTERMEDIATE:/            d             # special target
  /^\.SECONDARY:/               d             # special target
  /^\.SECONDEXPANSION/          d             # special target
  /^\.DELETE_ON_ERROR:/         d             # special target
  /^\.IGNORE:/                  d             # special target
  /^\.LOW_RESOLUTION_TIME:/     d             # special target
  /^\.SILENT:/                  d             # special target
  /^\.EXPORT_ALL_VARIABLES:/    d             # special target
  /^\.NOTPARALLEL:/             d             # special target
  /^\.ONESHELL:/                d             # special target
  /^\.POSIX:/                   d             # special target
  /^\.NOEXPORT:/                d             # special target
  /^\.MAKE:/                    d             # special target

# The stuff above here describes lines that are not
#  explicit targets or not targets other than special ones
# The stuff below here decides whether an explicit target
#  should be output.

  /^[^#\t:=%]+:([^=]|$)/ {                    # found target block
    h                                         # hold target
    d                                         # delete line
  }
  /^# File is an intermediate prerequisite/ { # nope
    s/^.*$//;x                                # unhold target
    d                                         # delete line
  }
  /^([^#]|$)/ {                               # end of target block
    s/^.*$//;x                                # unhold target
    s/:.*$//p                                 # write current target
    d                                         # hide any bugs
  }
'

make -npq .DEFAULT 2>/dev/null | sed -n -r "$SCRIPT" \
  | sort | uniq

Este é um script muito mais completo do que o script de conclusão debian bash porque fornece resultados para regras geradas que é o que a pergunta pede e a resposta mais votada (script de conclusão debian bash no servidor git debian) não vai longe o suficiente.

Este não é o script original ao qual vinculei, mas é muito mais simples e um pouco mais rápido.

Este é o código para o alias baseado na solução Todd Hodes

alias mtargets='make -qp | awk -F":" "/^[a-zA-Z0-9][^$#\/\t=]*:([^=]|$)/ {split(\$1,A,/ /);for(i in A)print A[i]}"'

Isso dará uma boa saída:

make -pn | perl -F: -ane 'print "$F[0]\n" if /^\w+\s*:/' | sort

Há uma solução muito boa com alguma magia sed e egrep aqui: https://gist.github.com/pvdb/777954

Acho que estou um pouco atrasado para esta festa, mas se você está procurando um comando específico, pode tentar

make -qp | grep -v '^# ' | grep -v '^[[:space:]]' | grep --only-matching '^.*:'

Isso geralmente funciona, embora ainda possa incluir algumas coisas não-alvo, como uma vpathdiretiva. Se você não depende makedas regras integradas de, você pode usar make -qpRcomo o primeiro comando no pipeline.

Solução Ruby:

`make -qp`.split("\n").select{|l| l =~ /^\w/ && l !~ /=/}.map{|l| l.sub(/:.*/,'')}

Estou trabalhando em solaris 10 e turbo C shell. A solução fornecida não funciona para meu projeto makefile. mesmo depois de alterar a linha de comando acima para a sintaxe tcsh. No entanto, descobri que você pode obter uma solução fácil usando

remake --tasks | grep -v "clean some static output or just grep tabs on start of line" | awk ´{print $1}´

versão remake:

remake --version

é

GNU Make 3.82+dbg0.8
Built for sparc-sun-sparc2-9

e alguns outros dados de versão sem importância

Procurei a mesma pergunta e encontrei este giro:

make -pn | sed -rn '/^[^# \t\.%].*:/p'

Isso remove todas as linhas de comentário, regras de padrão (linhas que começam com tabulações), todos os intrínsecos (exemplo .c.oe %.o: %.cpadrões).

Encontrei esta solução em outro tópico:

sh -c "cat Makefile | egrep \"^[[:alnum:][:punct:]]{0,}:[[:space:]]{0,}[[:alnum:][:punct:][:space:]]{0,}$\""

Você também pode adicioná-lo ao seu Makefile:

list:
    sh -c "cat Makefile | egrep \"^[[:alnum:][:punct:]]{0,}:[[:space:]]{0,}[[:alnum:][:punct:][:space:]]{0,}$\\""

E execute make list.

Claro, mas quando você quer que ele os cuspa?

Para relatar o nome do alvo quando ele executa a regra, coloque uma linha na regra:

foo$(VAR): $(PREREQS)
    @echo now making the foo target: $@
    do_other_stuff...

Para cuspi-los todos de uma vez, você pode criar um alvo PHONY separado:

.PHONY: show_vars
show_vars:
    @echo foo$(VAR)
    @echo bar$(PARAM) blah$(FLAG)
    # and so on

E isso pode ser um pré-requisito de seu destino padrão:

all: show_vars
    ...

EDITAR:
Você quer uma maneira de mostrar todos os alvos possíveis de um makefile arbitrário, o que eu suponho que significa não intrusivamente. Bem...

Para fazer isso exatamente, e ser capaz de lidar com makefiles sofisticados, por exemplo, envolvendo regras construídas por evalinstruções, você teria que escrever algo próximo a um emulador Make. Impraticável.

Para ver os alvos das regras simples, você poderia escrever um makefile que atuaria como um scanner makefile, operando em um makefile arbitrário:

1. Pegue todos os nomes de destino do makefile usando sed.
2. `inclua` o makefile para usá-lo para expandir variáveis.
3. Use `show_%:; echo $$ * `para imprimir todos os alvos

Este seria um trabalho impressionante. Tem certeza de que o objetivo vale o esforço?

grep ^[a-z].*\:$ Makefile | sed s,:,,g