Insert a new-line in a Makefile $(foreach ) loop

Question

I'm compiling a large list of files in a Makefile.

my.list : ${deps}
    rm -f $@
    $(foreach F,$^,echo "${F}" >> $@;)

but ${deps} can be large and the generated command-line could be too large for one SHELL call. Is it possible to replace ';' by a newline '\n' ?

Answer 1

As already mentioned in Jonathan Wakely's answer, the straightforward answer is

define newline


endef

Interestingly enough, for all chars except newline there is an easier way to get non-printable characters into variables with some help from the shell, e.g.:

tab := $(shell printf '\011')

It won't work here, though, because the builtin shell function replaces all newlines by spaces.

The version above is still a bit fragile though, in particular when combining with automake which will silently remove the second consecutive newline from the input file, turning newline into an empty variable. To force it to keep the newline, we can extend the snippet:

blank :=
define newline

$(blank)
endef

Finally, to actually get a separate shell command for each dependency, you need to run the generated string through eval:

define generate-rule =
my.list : $(1)
    rm -f $$@
    $(foreach F,$$^,$(newline)$(tab)echo "${F}" >> $@)

endef

$(eval $(call generate-rule,$(deps)))

Answer 2

You can define a variable that expands to a newline like so:

define NEWLINE

endef

Now you can use $(NEWLINE) to expand to a newline.

This won't change anything though, the foreach will still generate a single command with embedded newlines between the statements, rather than a single command with ; between the statements.

Answer 3

Possibly the most straight-forward answer is to use:

@printf "\n"

You can also use this, as I commonly do, to show a description when each new make target executes. An example target:

.PHONY: clean-version
clean-version:    ## Reset version back to committed version number
    @printf "\n## Reset version to last committed version number ##\n\n"; \
    $(GIT) checkout $(VERSION_FILE);

Answer 4

Replacing ';' by a carriage-return will produce a string of the same size, subject to the same problem.

"foreach" is simply a string expansion. If you want to execute a separate command for each item, you can use a for loop.

my.list : ${deps}
    rm -f $@
    (for F in $^; do echo $$F >> $@ ; done)

Answer 5

Edit -- after some revisions, it looks like the only problem with my original was not due to the whitespaces, but with MAKE_O. I've fixed it in my version, but I'll mostly be removing them below.

By the way the original post was written, I'm not sure if my solution will be relevant. However, I found myself in the middle of a define already inside a foreach, and couldn't figure out how to insert a newline using any of the other answers as given.

Solution:

define BR
$(1)

endef

define MAKE_O
$(1): $(wildcard $(1:obj/%.o=src/%.cpp)); \
        $(CXX) ... -c $$< \$(call BR)-o $1 ... \
                \$(call BR)&& touch $$@
endef
$(foreach N,main.o,$(eval $(call MAKE_O,$(N))))

Desired output (compilation is truncated from auto-dependency generation, hence the touch):

> make obj/main.o
g++ ... -c src/main.cpp \
-o obj/main.o ... \
&& touch obj/main.o

I changed BR to perform the indentation but leave the end of the line up to you:

define BR
$(1)
$(1:%= )        #<remove this comment
endef
define MAKE_O
$(1): $(wildcard $(1:obj/%.o=src/%.cpp)); \
        $(CXX) ... -c $$< $(call BR,\)-o $1 ... \
                $(call BR,\)&& touch $$@
endef
$(foreach N,main.o,$(eval $(call MAKE_O,$(N))))

The markup won't help to show this, but line 2 of BR is $(1:%=_space_)_tab_ (the comment itself is not allowed.) Result:

> make -n obj/main.o
g++ obj/main.o -c \
        -o obj/main.o && \
        echo statement on new line

I used $(call BR,\) so that the newline was not parsed as an escape of the new line, and $(1:%=space)tab so that the tab is forced (many similar rules have been defined, like SPACE:=$(SPACE) $(SPACE) without a prior value.) The variable left of the whitespace must evaluate to something. To be clear, removing the whitespace before and after the call: ...lastword$(call BR,\)firstword... yields ...lastword\n\tfirstword..., or written out,

[^]...lastword \[$]
[^]$(call BR,\)firstword...[$]

...yields...

[^]...lastword \[$]
[^]        firstword...[$]

to achieve the same (using ^,$ to denote the beginning and end of the line. Someone else will probably know how to format/annotate this better.)

My syntax highlighter is decidedly unimpressed with the 'escaped' parentheses and trailing whitespace, but the result is decent.