Wypisz cele / cele w marce GNU, które zawierają zmienne w swojej definicji

Mam dość duży plik makefile, który tworzy wiele celów w locie, obliczając nazwy ze zmiennych. (np. foo $ (VAR): $ (PREREQS)). Czy istnieje sposób, w jaki można przekonać gnu make do wyplucia listy celów po rozwinięciu tych zmiennych?

Chciałbym móc znaleźć cele dla aribitrary makefile. Próbuję napisać funkcję uzupełniającą dla mojej powłoki.

Czy możesz przeanalizować dane wyjściowe z make -pn(tj. make --print-data-base --dry-run)? Wyświetla wszystkie zmienne, reguły, reguły niejawne i polecenia, które będą uruchamiane ze szczegółami.

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

Zaczerpnięte z zakończenia make arg, które działa jak urok.

Nie jestem pewien, czy to tylko kwestia tworzenia GNU, ale działa to dobrze:

make help

Kilku respondentów zasugerowało użycie make -pn, które wypisze bazę danych reguł, ale niczego nie wykona - mniej więcej. Problem z tym podejściem polega na tym, -nże nadal wywołuje wszystkie rekurencyjne marki i nadal wykonuje o wiele więcej pracy niż to konieczne, ponieważ wypisuje każde polecenie, które wywołałoby w normalnej kompilacji. Bardziej wydajnym rozwiązaniem byłoby utworzenie trywialnego pliku makefile dummy.mk o następującej zawartości:

__all_targets__: ; #no-op

Teraz wywołaj make as make -p -f Makefile -f dummy.mk __all_targets__. W przypadku każdej znaczącej budowy różnica w ilości produkcji generowanej przez markę jest znacząca. Na przykład:

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

Czas wykonania również był znacznie lepszy - 2,063 s dla pierwszej wersji, 0,059 s dla drugiej.

Sprawdź ukończenie bash dla marki w GitHub.

Edycja: FYI repozytorium git do zakończenia debian bash w innej odpowiedzi zawiera teraz ulepszoną wersję tego skryptu dostosowaną do przypadków użycia 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

Jest to znacznie bardziej kompletny skrypt niż skrypt uzupełniający debian bash, ponieważ zapewnia wyniki dla wygenerowanych reguł, o które zadaje się pytanie, a najczęściej głosowana odpowiedź (skrypt uzupełniający debian bash na serwerze debian git) nie jest wystarczająca.

To nie jest oryginalny skrypt, z którym się łączyłem, ale jest znacznie prostszy i odrobinę szybszy.

To jest kod aliasu oparty na rozwiązaniu Todda Hodesa

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

To da ładny wynik:

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

Jest tutaj bardzo fajne rozwiązanie z odrobiną magii sed i egrep: https://gist.github.com/pvdb/777954

Chyba trochę się spóźniłem na to przyjęcie, ale jeśli szukasz konkretnego polecenia, możesz spróbować

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

To w większości działa, chociaż nadal może zawierać pewne elementy niebędące celem, takie jak vpathdyrektywa. Jeśli nie polegasz na makewbudowanych regułach, możesz użyć make -qpRjako pierwszego polecenia w potoku.

Rozwiązanie Ruby:

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

Pracuję nad powłoką Solaris 10 i Turbo C. Podane rozwiązanie nie działa dla mojego projektu makefile. nawet po zmianie powyższego wiersza poleceń na składnię tcsh. Jednak dowiedziałem się, że możesz uzyskać łatwe rozwiązanie za pomocą

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

wersja remake:

remake --version

jest

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

i kilka innych nieistotnych danych o wersji

Szukałem tego samego pytania i wymyśliłem ten spin:

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

To usuwa wszystkie linie komentarzy, reguły wzorców (linie zaczynające się od tabulatorów), wszystkie elementy wewnętrzne (przykłady .c.oi %.o: %.cwzorce).

Znalazłem to rozwiązanie w innym wątku:

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

Możesz również dodać go do Makefile:

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

I wykonaj make list.

Jasne, ale kiedy chcesz, żeby je wypluła?

Aby zgłosić nazwę celu po uruchomieniu reguły, umieść wiersz w regule:

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

Aby wypluć je wszystkie na raz, możesz stworzyć osobny cel PHONY:

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

Można to uczynić warunkiem wstępnym domyślnego celu:

all: show_vars
    ...

EDYTOWAĆ:
Chcesz sposobu, aby pokazać wszystkie możliwe cele dowolnego pliku makefile, co, jak przypuszczam, oznacza nieinwazyjne. Dobrze...

Aby to zrobić dokładnie i móc poradzić sobie z wyrafinowanymi plikami makefile, np. Zawierającymi reguły skonstruowane przez evalinstrukcje, musiałbyś napisać coś zbliżonego do emulatora Make. Niepraktyczny.

Aby zobaczyć cele prostych reguł, możesz napisać plik makefile, który działałby jak skaner makefile, działający na dowolnym pliku makefile:

1. Pobierz wszystkie nazwy celów z pliku makefile za pomocą seda.
2. `include` makefile, aby użyć go do rozwinięcia zmiennych.
3. Użyj `show_%:; echo $$ * `wypisuje wszystkie cele

To byłaby imponująca praca. Czy na pewno ten cel jest wart wysiłku?

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