How do you get the list of targets in a makefile

Question

I ve used rake a bit  a Ruby make program   and it has an option to get a list of all the available targets  eg   gt  rake --tasks rake db charset        retrieve the charset for your data    rake db collation      retrieve the collation for your da    rake db create         Creates the databases defined in y    rake db drop           Drops the database for your curren          but there seems to be no option to do this in GNU make    Apparently the code is almost there for it  as of 2007 - http   www mail-archive com help-make gnu org msg06434 html    Anyway  I made little hack to extract the targets from a makefile  which you can include in a makefile    list       grep        space        Makefile   It will give you a list of the defined targets  It s just a start - it doesn t filter out the dependencies  for instance     gt  make list list  copy  run  plot  turnin

User · Accepted Answer

This is an attempt to improve on Brent Bradburn's great approach as follows:

uses a more robust command to extract the target names, which hopefully prevents any false positives (and also does away with the unnecessary sh -c)
does not invariably target the makefile in the current directory; respects makefiles explicitly specified with -f <file>
excludes hidden targets - by convention, these are targets whose name starts neither with a letter nor a digit
makes do with a single phony target
prefixes the command with @ to prevent it from being echoed before execution

Curiously, GNU make has no feature for listing just the names of targets defined in a makefile. While the -p option produces output that includes all targets, it buries them in a lot of other information and also executes the default target (which could be suppressed with -f/dev/null).

Place the following rule in a makefile for GNU make to implement a target named list that simply lists all target names in alphabetical order - i.e.: invoke as make list:

.PHONY: list
list:
    @$(MAKE) -pRrq -f $(lastword $(MAKEFILE_LIST)) : 2>/dev/null | awk -v RS= -F: '/^# File/,/^# Finished Make data base/ {if ($$1 !~ "^[#.]") {print $$1}}' | sort | egrep -v -e '^[^[:alnum:]]' -e '^$@$$'

Important: On pasting this, make sure that the last line is indented by exactly 1 actual tab char. (spaces do not work).

Note that sorting the resulting list of targets is the best option, since not sorting doesn't produce a helpful ordering in that the order in which the targets appear in the makefile is not preserved.
Also, the sub-targets of a rule comprising multiple targets are invariably output separately and will therefore, due to sorting, usually not appear next to one another; e.g., a rule starting with a z: will not have targets a and z listed next to each other in the output, if there are additional targets.

Explanation of the rule:

.PHONY: list
- declares target list a phony target, i.e., one not referring to a file, which should therefore have its recipe invoked unconditionally
$(MAKE) -pRrq -f $(lastword $(MAKEFILE_LIST)) : 2>/dev/null
- Invokes make again in order to print and parse the database derived from the makefile:
  - -p prints the database
  - -Rr suppresses inclusion of built-in rules and variables
  - -q only tests the up-to-date-status of a target (without remaking anything), but that by itself doesn't prevent execution of recipe commands in all cases; hence:
  - -f $(lastword $(MAKEFILE_LIST)) ensures that the same makefile is targeted as in the original invocation, regardless of whether it was targeted implicitly or explicitly with -f ....
    Caveat: This will break if your makefile contains include directives; to address this, define variable THIS_FILE := $(lastword $(MAKEFILE_LIST)) before any include directives and use -f $(THIS_FILE) instead.
  - : is a deliberately invalid target that is meant to ensure that no commands are executed; 2>/dev/null suppresses the resulting error message. Note: This relies on -p printing the database nonetheless, which is the case as of GNU make 3.82. Sadly, GNU make offers no direct option to just print the database, without also executing the default (or given) task; if you don't need to target a specific Makefile, you may use make -p -f/dev/null, as recommended in the man page.
-v RS=
- This is an awk idiom that breaks the input into blocks of contiguous non-empty lines.
/^# File/,/^# Finished Make data base/
- Matches the range of lines in the output that contains all targets (true as of GNU make 3.82) - by limiting parsing to this range, there is no need to deal with false positives from other output sections.
if ($$1 !~ "^[#.]")
- Selectively ignores blocks:
  - # ... ignores non-targets, whose blocks start with # Not a target:
  - . ... ignores special targets
- All other blocks should each start with a line containing only the name of an explicitly defined target followed by :
egrep -v -e '^[^[:alnum:]]' -e '^$@$$' removes unwanted targets from the output:
- '^[^[:alnum:]]' ... excludes hidden targets, which - by convention - are targets that start neither with a letter nor a digit.
- '^$@$$' ... excludes the list target itself

Running make list then prints all targets, each on its own line; you can pipe to xargs to create a space-separated list instead.

User · Answer

not sure why the previous answer was so complicated   list      cat Makefile   grep    A-z     awk   print   1     sed  s    g

User · Answer

This one was helpful to me because I wanted to see the build targets required  and their dependencies  by the make target  I know that make targets cannot begin with a     character  I don t know what languages are supported  so I went with egrep s bracket expressions   cat Makefile   egrep      alnum    punct    0      space    0     alnum    punct    space    0

User · Answer

Under Bash  at least   this can be done automatically with tab completion   make spacetabtab

User · Answer

Yet another additional answer to above  tested on MacOSX using only cat and awk on terminal cat Makefile   awk    SHELL   amp  amp     A-z    print  1     awk   print substr  0  1  length  0 -1     will output of the make file like below   target1 target2 target3  in the Makefile  it should be the same statement  ensure that you escape the variables using   variable rather than  variable  Explanation cat - spits out the contents   - pipe parses output to next awk awk - runs regex excluding  quot shell quot  and accepting only  quot A-z quot  lines then prints out the  1 first column awk - yet again removes the last character  quot   quot  from the list this is a rough output and you can do more funky stuff with just AWK  Try to avoid sed as its not as consistent in BSDs variants i e  some works on  nix but fails on BSDs like MacOSX  More You should be able add this  with modifications  to a file for make  to the default bash-completion folder  usr local etc bash-completion d  meaning when you  quot make tab tab quot     it will complete the targets based on the one liner script

User · Answer

I combined these two answers  https   stackoverflow com a 9524878 86967 and https   stackoverflow com a 7390874 86967 and did some escaping so that this could be used from inside a makefile    PHONY  no targets   list no targets    list      sh -c    MAKE  -p no targets     awk -F        a-zA-Z0-9           t                split    1 A      for i in A print A i      grep -v           sort         make -s list build clean default distclean doc fresh install list makefile    this is kind of extraneous  but whatever    run

User · Answer

My favorite answer to this was posted by Chris Down at Unix  amp  Linux Stack Exchange  I ll quote      This is how the bash completion module for make gets its list   make -qp   awk -F        a-zA-Z0-9        t               split  1 A      for i in A print A i          It prints out a newline-delimited list of targets  without paging    User Brainstone suggests piping to sort -u to remove duplicate entries   make -qp   awk -F        a-zA-Z0-9        t               split  1 A      for i in A print A i      sort -u   Source  How to list all targets in make   Unix amp Linux SE

User · Answer

I usually do       grep install targets Makefile   It would come back with something like    install targets   install-xxx1 install-xxx2     etc   I hope this helps

User · Answer

This help target will only print targets which have    followed by a description  This allows for documenting both public and private targets  Using the  DEFAULT GOAL makes the help more discoverable  Only sed  xargs and printf used which are pretty common  Using the  lt    MAKEFILE LIST  allows for the makefile to be called something other than Makefile for instance Makefile github You can customize the output to suit your preference in the printf  This example is set up to match the OP s request for rake style output When cutting and pasting the below make file  don t forget to change the 4 spaces indentation to tabs    vim ft make   Makefile   DEFAULT GOAL    help  PHONY  test help  help      these help instructions      sed -rn  s    a-zA-Z -                  quot  1 quot   quot  2 quot  p   lt    MAKEFILE LIST    xargs printf  quot make  -20s   s n quot   lint     style  bug and quality checker     pylint src test  private    for internal usage only      true  test  private    run pytest with coverage     pytest --cov test    Here is the output from the Makefile above  Notice the private target doesn t get output because it only has a single   for it s comment    make make help                  these help instructions make lint                  style  bug and quality checker make test                  run pytest with coverage

User · Answer

For a Bash Script  Here s a very simple way to do this in bash -- based on the comment by  cibercitizen1 above   grep   Makefile   awk -F            print  1      See also the more authoritative answer by  Marc 2377  too  which says how the Bash completion module for make does it

User · Answer

This is far from clean  but did the job  for me   make -p 2 amp  gt  dev null   grep -A 100000    Files    grep -v        grep -v      s             grep -v  Makefile     cut -d     -f 1   I use make -p that dumps the internal database  ditch stderr  use a quick and dirty grep -A 100000 to keep the bottom of the output  Then I clean the output with a couple of grep -v  and finally use cut to get what s before the colon  namely  the targets   This is enough for my helper scripts on most of my Makefiles   EDIT  added grep -v Makefile that is an internal rule

User · Answer

nobar s answer helpfully shows how to use tab completion to list a makefile s targets    This works great for platforms that provide this functionality by default  e g   Debian  Fedora   On other platforms  e g   Ubuntu  you must explicitly load this functionality  as implied by  hek2mgl s answer       etc bash completion installs several tab-completion functions  including the one for make Alternatively  to install only tab completion for make       usr share bash-completion completions make        For platforms that don t offer this functionality at all  such as OSX  you can source the following commands  adapated from here  to implement it       complete make     COMPREPLY    compgen -W    make -pRrq   2 gt  dev null   awk -v RS  -F       File      Finished Make data base   if   1              print  1      egrep -v       alnum       sort   xargs   --    COMP WORDS  COMP CWORD         complete -F  complete make make    Note  This is not as sophisticated as the tab-completion functionality that comes with Linux distributions  most notably  it invariably targets the makefile in the current directory  even if the command line targets a different makefile with -f  lt file gt

User · Answer

This is a modification to jsp s very helpful answer  https   stackoverflow com a 45843594 814145   I like the idea of getting not only a list of targets but also their descriptions  jsp s Makefile puts the description as the comment  which I found often will be repeated in the target s description echo command  So instead  I extract the description from the echo command for each target    Example Makefile    PHONY  all all  build            same as  make build     PHONY  build build           echo  Build the project    PHONY  clean clean           echo  Clean the project    PHONY  help help           echo -n  Common make targets           echo              cat Makefile   sed -n      PHONY    h       t  echo    t      H  x   PHONY  s  PHONY         n               make  1 t 2 p  d  x    sort -k2 2  expand -t 20   Output of make help     make help Common make targets      make all        same as  make build      make build      Build the project     make clean      Clean the project     make help       Common make targets   Notes    Same as jsp s answer  only PHONY targets may be listed  which may or may not work for your case In addition  it only lists those PHONY targets that have a echo or   command as the first command of the recipe    means  do nothing   I use it here for those targets that no echo is needed  such as all target above  There is an additional trick for the help target to add the     in the make help output

User · Answer

I took a few answers mentioned above and compiled this one  which can also generate a nice description for each target and it works for targets with variables too  Example Makefile  APPS  app1 app2  bin    APPS     bin         Help  A composite target that relies only on other targets    APPS     bin     bin      echo  quot build binary quot         Help  A target with variable name  value       test      echo   MAKEFLAGS      echo  quot starting test quot         Help  A normal target without variables    A target without any help description clean      echo   MAKEFLAGS      echo  quot Cleaning    quot   MAKEOVERRIDES   help       printf  quot  -20s  s n quot   quot Target quot   quot Description quot       printf  quot  -20s  s n quot   quot ------ quot   quot ----------- quot       make -pqR   2 gt  dev null             awk -v RS  -F       File      Finished Make data base   if    1     quot       quot    print   1                sort             egrep -v -e       alnum     -e                     xargs -I   sh -c  printf  quot  -20s  quot     make   -nB    grep -i  quot    Help  quot     echo  quot  quot     tail -1   sed  quot s    Help    g quot    Example output    make help Target               Description ------               ----------- app1 bin             A target with variable name  value   app1 app2 bin             A target with variable name  value   app2 bin                  A composite target that relies only on other targets clean test                 A normal target without variables  How does it work  The top part of the make help target works exactly as posted by mklement0 here - How do you get the list of targets in a makefile   After getting the list of targets  it runs make  lt target gt  -nB as a dry run for each target and parses the last line that starts with    Help  for the description of the target  And that or an empty string is printed in a nicely formatted table  As you can see  the variables are even expanded within the description as well  which is a huge bonus in my book

User · Answer

To expand on the answer given by  jsp  you can even evaluate variables in your help text with the   eval  function  The proposed version below has these enhanced properties   Will scan any makefiles  even included  Will expand live variables referenced in the help comment Adds documentation anchor for real targets  prefixed with   TARGETDOC   Adds column headers  So to document  use this form  RANDOM VARIABLE    this will be expanded in help text   PHONY  target1   Target 1 help with   RANDOM VARIABLE  target1  deps          target 1 build commands     TARGETDOC    BUILDDIR  real-file txt   real-file txt help text   BUILDDIR  real-file txt             BUILDDIR  real-file txt build commands   Then  somewhere in your makefile   PHONY  help   Generate list of targets with descriptions help         find all help in targets and  PHONY and evaluate the embedded variables       eval doc expanded      shell grep -E -h     PHONY    TARGETDOC           MAKEFILE LIST    sed -E -n  s    PHONY   TARGETDOC                2   3  n  p   expand -t40        echo      echo   TARGET   HELP    expand -t40      echo   ------   ----    expand -t40      echo -e     doc expanded

User · Answer

This obviously won t work in many cases  but if your Makefile was created by CMake you might be able to run make help     make help The following are some of the valid targets for this Makefile      all  the default if no target is provided      clean     depend     install etc

User · Answer

As mklement0 points out  a feature for listing all Makefile targets is missing from GNU-make  and his answer and others provides ways to do this   However  the original post also mentions rake  whose tasks switch does something slightly different than just listing all tasks in the rakefile  Rake will only give you a list of tasks that have associated descriptions  Tasks without descriptions will not be listed  This gives the author the ability to both provide customized help descriptions and also omit help for certain targets   If you want to emulate rake s behavior  where you provide descriptions for each target  there is a simple technique for doing this  embed descriptions in comments for each target you want listed   You can either put the description next to the target or  as I often do  next to a PHONY specification above the target  like this    PHONY  target1   Target 1 help text target1  deps          target 1 build commands    PHONY  target2   Target 2 help text target2           target 2 build commands                                                                                                                  PHONY  help   Generate list of targets with descriptions                                                                 help                                                                                                                           grep    PHONY        Makefile   sed  s   PHONY                   1  2     expand -t20   Which will yield    make help target1             Target 1 help text target2             Target 2 help text      help                Generate list of targets with descriptions   You can also find a short code example in this gist and here too   Again  this does not solve the problem of listing all the targets in a Makefile  For example  if you have a big Makefile that was maybe generated or that someone else wrote  and you want a quick way to list its targets without digging through it  this won t help   However  if you are writing a Makefile  and you want a way to generate help text in a consistent  self-documenting way  this technique may be useful

User · Answer

Focusing on an easy syntax for describing a make target  and having a clean output  I chose this approach   help       grep -B1 -E    a-zA-Z0-9 -                Makefile          grep -v -- --          sed  N s  n                sed -n  s                         2    1 p           column -t  -s            Starts the container stack up  a b   command     Pulls in new container images pull  c d      another command  make-target-not-shown     this does not count as a description  so leaving   your implementation comments alone  e g TODOs also-not-shown    So treating the above as a Makefile and running it gives you something like   gt  make help up          Starts the container stack pull        Pulls in new container images   Explanation for the chain of commands    First  grep all targets and their preceeding line  see https   unix stackexchange com a 320709 223029  Then  get rid of the group separator  see https   stackoverflow com a 2168139 1242922  Then  we collapse each pair of lines to parse it later  see https   stackoverflow com a 9605559 1242922  Then  we parse for valid lines and remove those which do not match  see https   stackoverflow com a 8255627 1242922  and also give the output our desired order  command  then description  Lastly  we arrange the output like a table

User · Answer

If you have bash completion for make installed  the completion script will define a function  make target extract script  This function is meant to create a sed script which can be used to obtain the targets as a list   Use it like this     Make sure bash completion is enabled source  etc bash completion     List targets from Makefile sed -nrf  lt   make target extract script --  Makefile

User · Answer

Plenty of workable solutions here  but as I like saying   if it s worth doing once  it s worth doing again   I did upvote the sugestion to use  tab  tab   but as some have noted  you may not have completion support  or  if you have many include files  you may want an easier way to know where a target is defined   I have not tested the below with sub-makes   I think it wouldn t work  As we know  recursive makes considered harmful     PHONY  list ls ls list          search all include files for targets             excluding special targets  and output dynamic rule definitions unresolved       for inc in   MAKEFILE LIST   do       echo        inc             grep -Eo          blank             inc   grep -v              cut -f 1   sort   sed  s       amp      sed -n  s        p          tr          tr   open paren      tr   close paren        done    to get around escaping limitations  open paren       close paren         Which I like because    list targets by include file  output raw dynamic target definitions  replaces variable delimiters with modulo  output each target on a new line seems clearer  subjective opinion    Explanation    foreach file in the MAKEFILE LIST output the name of the file grep lines containing a colon  that are not indented  not comments  and don t start with a period exclude immediate assignment expressions      cut  sort  indent  and chop rule-dependencies  after colon  munge variable delimiters to prevent expansion   Sample Output      Makefile      includes   ls list    util kiss snapshots mk      rotate-db-snapshots   rotate-file-snapshots   snap-db   snap-files   snapshot    util kiss main mk      dirs   install     MK DIR PREFIX env-config php     MK DIR PREFIX    srdb

User · Answer

For AWK haters  and for simplicity  this contraption works for me  help    make -qpRr   lastword   MAKEFILE LIST     egrep -v             s          cut -d  -f1   for use outside a Makefile  just remove   lastword      or replace it with the Makefile path   This solution will not work if you have  quot interesting quot  rule names but will work well for most simple setups  The main downside of a make -qp based solution is  as in other answers here  that if the Makefile defines variable values using functions - they will still be executed regardless of -q  and if using   shell      then the shell command will still be called and its side effects will happen  In my setup often the side effects of running shell functions is unwanted output to standard error  so I add 2 gt  dev null after the make command

[makefile] How do you get the list of targets in a makefile?

Examples related to makefile

Examples related to gnu-make

Examples related to targets