如何在Makefile中编写循环？

我要执行以下命令：

./a.out 1
./a.out 2
./a.out 3
./a.out 4
.
.
. and so on

如何将此东西写成一个循环Makefile？

如果按照我的假设，如果您使用的./a.out是UNIX类型的平台，则将执行以下操作。

for number in 1 2 3 4 ; do \
    ./a.out $$number ; \
done

测试如下：

target:
    for number in 1 2 3 4 ; do \
        echo $$number ; \
    done

产生：

1
2
3
4

对于更大的范围，请使用：

target:
    number=1 ; while [[ $$number -le 10 ]] ; do \
        echo $$number ; \
        ((number = number + 1)) ; \
    done

这将输出1到10（含1和10），只需将while终止条件从10 更改为1000，就可以在注释中指出更大的范围。

嵌套循环可以这样完成：

target:
    num1=1 ; while [[ $$num1 -le 4 ]] ; do \
        num2=1 ; while [[ $$num2 -le 3 ]] ; do \
            echo $$num1 $$num2 ; \
            ((num2 = num2 + 1)) ; \
        done ; \
        ((num1 = num1 + 1)) ; \
    done

生产：

1 1
1 2
1 3
2 1
2 2
2 3
3 1
3 2
3 3
4 1
4 2
4 3

如果您使用的是GNU make，则可以尝试

号码= 1 2 3 4
做：
        $（foreach var，$（NUMBERS），。/ a.out $（var）;）

这将生成并执行

./a.out 1; ./a.out 2; ./a.out 3; ./a.out 4;

的主要原因使用make恕我直言，是-j标志。make -j5将一次运行5个Shell命令。如果您有4个CPU，并且对任何makefile都可以进行良好的测试，那么这很好。

基本上，您希望使之类似于：

.PHONY: all
all: job1 job2 job3

.PHONY: job1
job1: ; ./a.out 1

.PHONY: job2
job2: ; ./a.out 2

.PHONY: job3
job3: ; ./a.out 3

这很-j友好（一个好兆头）。你能发现样板吗？我们可以这样写：

.PHONY: all job1 job2 job3
all: job1 job2 job3
job1 job2 job3: job%:
    ./a.out $*

具有相同的效果（是的，就make而言，这与以前的配方相同，只是更加紧凑）。

进一步的参数设置，以便您可以在命令行上指定一个限制（这很麻烦，因为make它没有任何好的算术宏，因此我将在此处作弊并使用$(shell ...)）

LAST := 1000
NUMBERS := $(shell seq 1 ${LAST})
JOBS := $(addprefix job,${NUMBERS})
.PHONY: all ${JOBS}
all: ${JOBS} ; echo "$@ success"
${JOBS}: job%: ; ./a.out $*

使用来运行它make -j5 LAST=550，LAST默认为1000。

我意识到这个问题已有几年历史了，但是由于该帖子演示了一种与上述方法不同的方法，因此它可能仍对某人有用，并且它既不依赖于shell操作，也不依赖于开发人员淘汰硬编码数值字符串。

$（eval ....）内置宏是您的朋友。或者至少可以。

define ITERATE
$(eval ITERATE_COUNT :=)\
$(if $(filter ${1},0),,\
  $(call ITERATE_DO,${1},${2})\
)
endef

define ITERATE_DO
$(if $(word ${1}, ${ITERATE_COUNT}),,\
  $(eval ITERATE_COUNT+=.)\
  $(info ${2} $(words ${ITERATE_COUNT}))\
  $(call ITERATE_DO,${1},${2})\
)
endef

default:
  $(call ITERATE,5,somecmd)
  $(call ITERATE,0,nocmd)
  $(info $(call ITERATE,8,someothercmd)

这是一个简单的例子。对于较大的值，它不会很好地缩放-它可以工作，但是随着ITERATE_COUNT字符串每次迭代将增加2个字符（空格和点），当您达到数千时，对单词的计数将逐渐变长。如所写，它不处理嵌套迭代（您需要一个单独的迭代函数和计数器来执行此操作）。这纯粹是gnu make，没有shell要求（尽管显然OP每次都希望运行一个程序-在这里，我只是显示一条消息）。ITERATE中的if旨在捕获值0，因为$（word ...）否则会出错。

请注意，由于内置的​​$（words ...）可以提供阿拉伯数字，因此使用了用作计数器的不断增长的字符串，但是make否则不支持数学运算（您不能将1 + 1赋给某对象并得到2，除非您是从shell调用某些东西来为您完成此操作，或者使用等价的宏操作）。这对于递增计数器非常有用，但是对于递减计数器却不太好。

我本人并没有使用它，但是最近，我需要编写一个递归函数来评估跨多二进制，多库构建环境的库依赖关系，在其中需要包括其他库时引入其他库。本身还有其他依赖项（其中一些依赖于构建参数而有所不同），我使用类似于上面的$（eval）和counter方法（在我的情况下，counter用于确保我们不会以某种方式陷入困境循环，并作为诊断报告需要多少迭代）。

其他东西一无是处，尽管对OP的意义不大：$（eval ...）提供了一种规避make内部对循环引用的厌恶的方法，当变量是宏类型时（用=），而不是立即分配（用：=初始化）。有时候，您希望能够在其自己的赋值中使用变量，而$（eval ...）将使您能够做到这一点。这里要考虑的重要事项是，在运行eval时，变量将被解析，并且已解析的部分不再被视为宏。如果您知道自己在做什么，并且试图在RHS分配给自己的变量上使用变量，那么通常这就是您想发生的事情。

  SOMESTRING = foo

  # will error.  Comment out and re-run
  SOMESTRING = pre-${SOMESTRING}

  # works
  $(eval SOMESTRING = pre${SOMESTRING}

default:
  @echo ${SOMESTRING}

快乐的化妆。

为了实现跨平台支持，请配置命令分隔符（用于在同一行上执行多个命令）。

例如，如果您在Windows平台上使用MinGW，则命令分隔符为&：

NUMBERS = 1 2 3 4
CMDSEP = &
doit:
    $(foreach number,$(NUMBERS),./a.out $(number) $(CMDSEP))

这将在一行中执行串联的命令：

./a.out 1 & ./a.out 2 & ./a.out 3 & ./a.out 4 &

如其他地方所述，在* nix平台上使用CMDSEP = ;。

这实际上不是对问题的纯粹答案，而是解决此类问题的明智方法：

无需编写复杂的文件，只需将控制委托给一个bash脚本，例如：makefile

foo : bar.cpp baz.h
    bash script.sh

和script.sh看起来像：

for number in 1 2 3 4
do
    ./a.out $number
done

也许您可以使用：

xxx:
    for i in `seq 1 4`; do ./a.out $$i; done;

您可以将其set -e用作for循环的前缀。例：

all:
    set -e; for a in 1 2 3; do /bin/false; echo $$a; done

make将立即以退出代码退出<> 0。

尽管GNUmake表工具包具有一个真实的while循环（无论在GNUmake编程中具有两个或三个执行阶段），但如果需要的是迭代列表，则可以使用提供一个简单的解决方案interval。有趣的是，我们也将数字转换为十六进制：

include gmtt/gmtt.mk

# generate a list of 20 numbers, starting at 3 with an increment of 5
NUMBER_LIST := $(call interval,3,20,5)

# convert the numbers in hexadecimal (0x0 as first operand forces arithmetic result to hex) and strip '0x'
NUMBER_LIST_IN_HEX := $(foreach n,$(NUMBER_LIST),$(call lstrip,$(call add,0x0,$(n)),0x))

# finally create the filenames with a simple patsubst
FILE_LIST := $(patsubst %,./a%.out,$(NUMBER_LIST_IN_HEX))

$(info $(FILE_LIST))

输出：

./a3.out ./a8.out ./ad.out ./a12.out ./a17.out ./a1c.out ./a21.out ./a26.out ./a2b.out ./a30.out ./a35.out ./a3a.out ./a3f.out ./a44.out ./a49.out ./a4e.out ./a53.out ./a58.out ./a5d.out ./a62.out

一个简单的，与shell /平台无关的纯宏解决方案是...

%sequence = $(if $(word ${1},${2}),$(wordlist 1,${1},${2}),$(call %sequence,${1},${2} $(words _ ${2})))

$(foreach i,$(call %sequence,10),$(info ./a.out ${i}))

#I have a bunch of files that follow the naming convention
#soxfile1  soxfile1.o  soxfile1.sh   soxfile1.ini soxfile1.txt soxfile1.err
#soxfile2  soxfile2.o   soxfile2.sh  soxfile2.ini soxfile2.txt soxfile2.err
#sox...        ....        .....         ....         ....        ....
#in the makefile, only select the soxfile1.. soxfile2... to install dir
#My GNU makefile solution follows:
tgt=/usr/local/bin/          #need to use sudo
tgt2=/backup/myapplication/  #regular backup 

install:
        for var in $$(ls -f sox* | grep -v '\.' ) ; \
        do \
                sudo  cp -f $$var ${TGT} ;     \
                      cp -f  $$var ${TGT2} ;  \
        done


#The ls command selects all the soxfile* including the *.something
#The grep command rejects names with a dot in it, leaving  
#My desired executable files in a list.