Enumere los objetivos / metas en GNU que contienen variables en su definición

Tengo un archivo MAKE bastante grande que crea varios objetivos sobre la marcha calculando nombres a partir de variables. (por ejemplo, foo $ (VAR): $ (PREREQS)). ¿Hay alguna forma de convencer a gnu make de que arroje una lista de objetivos después de haber expandido estas variables?

Me gustaría poder obtener los objetivos para un archivo MAKE arbitrario. Estoy tratando de escribir una función de finalización para mi shell.

¿Puede analizar la salida de make -pn(es decir make --print-data-base --dry-run)? Imprime todas las variables, reglas, reglas implícitas y qué comandos se ejecutarán con laborioso detalle.

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

Tomado de la finalización de make arg, que funciona a la perfección.

No estoy seguro de si esto es solo una cosa de gnu make, pero esto funciona bien:

make help

Varios respondedores han sugerido usar make -pn, que imprimirá la base de datos de reglas pero no ejecutará nada, más o menos. El problema con este enfoque es que -naún invoca todas las marcas recursivas, y aún hace mucho más trabajo del necesario, porque imprime todos los comandos que habría invocado en una compilación normal. Una solución más eficiente sería crear un archivo MAKE trivial, dummy.mk, con estos contenidos:

__all_targets__: ; #no-op

Ahora invoque make as make -p -f Makefile -f dummy.mk __all_targets__. En cualquier construcción sustancial, la diferencia en la cantidad de salida generada por la marca es significativa. Por ejemplo:

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

El tiempo de ejecución también fue dramáticamente mejor: 2.063 segundos para la primera versión, 0.059 segundos para la segunda.

Consulte la finalización de bash para make en GitHub.

Editar: Para su información, el repositorio de git de finalización de bash de Debian en otra respuesta ahora incorpora una versión mejorada de este script adaptada a los casos de uso de finalización de 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 es un script mucho más completo que el script de finalización de debian bash porque proporciona resultados para las reglas generadas que es lo que pide la pregunta y la respuesta más votada (script de finalización de debian bash en el servidor git de debian) no va lo suficientemente lejos.

Este no es el guión original al que me vinculé, pero es mucho más simple y un poco más rápido.

Este es el código para alias basado en la solución de Todd Hodes

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

Esto dará un buen resultado:

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

Hay una solución muy agradable con algo de magia sed y egrep aquí: https://gist.github.com/pvdb/777954

Supongo que llego un poco tarde a esta fiesta, pero si estás buscando un comando específico, puedes probar

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

Esto funciona principalmente, aunque aún puede incluir algunas cosas que no son de destino, como una vpathdirectiva. Si no depende de makelas reglas integradas de ', puede utilizarlo make -qpRcomo primer comando de la canalización.

Solución de rubí:

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

Estoy trabajando en solaris 10 y turbo C shell. La solución dada no funciona para mi proyecto makefile. incluso después de alterar la línea de comando anterior a la sintaxis tcsh. Sin embargo, descubrí que puede obtener una solución fácil usando

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

versión de remake:

remake --version

es

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

y algunos otros datos de versión sin importancia

Fui a buscar la misma pregunta y se me ocurrió este giro:

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

Esto elimina todas las líneas de comentarios, reglas de patrones (líneas que comienzan con tabulaciones), todos los elementos intrínsecos (ejemplo .c.oy %.o: %.cpatrones).

Encontré esta solución en otro hilo:

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

También puede agregarlo a su Makefile:

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

Y ejecutar make list.

Claro, pero ¿cuándo quieres que los escupe?

Para informar el nombre del objetivo cuando ejecuta la regla, coloque una línea en la regla:

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

Para escupirlos todos a la vez, puede hacer un objetivo PHONY separado:

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

Y esto puede convertirse en un requisito previo de su objetivo predeterminado:

all: show_vars
    ...

EDITAR:
desea una forma de mostrar todos los objetivos posibles de un archivo MAKE arbitrario, lo que supongo que significa de forma no intrusiva. Bien...

Para hacerlo exactamente, y ser capaz de manejar archivos MAKE sofisticados, por ejemplo, que involucren reglas construidas por evaldeclaraciones, tendría que escribir algo parecido a un emulador Make. Poco práctico.

Para ver los objetivos de las reglas simples, puede escribir un archivo MAKE que actuaría como un escáner de archivos MAKE, operando en un archivo MAKE arbitrario:

1. Obtenga todos los nombres de destino del archivo MAKE usando sed.
2. `incluir` el archivo MAKE para usarlo para expandir variables.
3. Utilice `show_%:; echo $$ * `para imprimir todos los objetivos

Este sería un trabajo impresionante. ¿Estás seguro de que el objetivo merece la pena?

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