summaryrefslogtreecommitdiff
path: root/tests/scripts/features/targetvars
blob: 18dd0239698bb83c121ed20cfdb524afdd899e45 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
#                                                                    -*-perl-*-
$description = "Test target-specific variable settings.";

$details = "\
Create a makefile containing various flavors of target-specific variable
values, override and non-override, and using various variable expansion
rules, semicolon interference, etc.";

open(MAKEFILE,"> $makefile");

print MAKEFILE <<'EOF';
SHELL = /bin/sh
export FOO = foo
export BAR = bar
one: override FOO = one
one two: ; @echo $(FOO) $(BAR)
two: BAR = two
three: ; BAR=1000
	@echo $(FOO) $(BAR)
# Some things that shouldn't be target vars
funk : override
funk : override adelic
adelic override : ; echo $@
# Test per-target recursive variables
four:FOO=x
four:VAR$(FOO)=ok
four: ; @echo '$(FOO) $(VAR$(FOO)) $(VAR) $(VARx)'
five:FOO=x
five six : VAR$(FOO)=good
five six: ;@echo '$(FOO) $(VAR$(FOO)) $(VAR) $(VARx) $(VARfoo)'
# Test per-target variable inheritance
seven: eight
seven eight: ; @echo $@: $(FOO) $(BAR)
seven: BAR = seven
seven: FOO = seven
eight: BAR = eight
# Test the export keyword with per-target variables
nine: ; @echo $(FOO) $(BAR) $$FOO $$BAR
nine: FOO = wallace
nine-a: export BAZ = baz
nine-a: ; @echo $$BAZ
# Test = escaping
EQ = =
ten: one\=two
ten: one \= two
ten one$(EQ)two $(EQ):;@echo $@
.PHONY: one two three four five six seven eight nine ten $(EQ) one$(EQ)two
# Test target-specific vars with pattern/suffix rules
QVAR = qvar
RVAR = =
%.q : ; @echo $(QVAR) $(RVAR)
foo.q : RVAR += rvar
# Target-specific vars with multiple LHS pattern rules
%.r %.s %.t: ; @echo $(QVAR) $(RVAR) $(SVAR) $(TVAR)
foo.r : RVAR += rvar
foo.t : TVAR := $(QVAR)
EOF

close(MAKEFILE);

# TEST #1

&run_make_with_options($makefile, "one two three", &get_logfile);
$answer = "one bar\nfoo two\nBAR=1000\nfoo bar\n";
&compare_output($answer,&get_logfile(1));

# TEST #2

&run_make_with_options($makefile, "one two FOO=1 BAR=2", &get_logfile);
$answer = "one 2\n1 2\n";
&compare_output($answer,&get_logfile(1));

# TEST #3

&run_make_with_options($makefile, "four", &get_logfile);
$answer = "x ok  ok\n";
&compare_output($answer,&get_logfile(1));

# TEST #4

&run_make_with_options($makefile, "seven", &get_logfile);
$answer = "eight: seven eight\nseven: seven seven\n";
&compare_output($answer,&get_logfile(1));

# TEST #5

&run_make_with_options($makefile, "nine", &get_logfile);
$answer = "wallace bar wallace bar\n";
&compare_output($answer,&get_logfile(1));

# TEST #5-a

&run_make_with_options($makefile, "nine-a", &get_logfile);
$answer = "baz\n";
&compare_output($answer,&get_logfile(1));

# TEST #6

&run_make_with_options($makefile, "ten", &get_logfile);
$answer = "one=two\none bar\n=\nfoo two\nten\n";
&compare_output($answer,&get_logfile(1));

# TEST #6

&run_make_with_options($makefile, "foo.q bar.q", &get_logfile);
$answer = "qvar = rvar\nqvar =\n";
&compare_output($answer,&get_logfile(1));

# TEST #7

&run_make_with_options($makefile, "foo.t bar.s", &get_logfile);
$answer = "qvar = qvar\nqvar =\n";
&compare_output($answer,&get_logfile(1));


# TEST #8
# For PR/1378: Target-specific vars don't inherit correctly

$makefile2 = &get_tmpfile;

open(MAKEFILE,"> $makefile2");
print MAKEFILE <<'EOF';
foo: FOO = foo
bar: BAR = bar
foo: bar
bar: baz
baz: ; @echo $(FOO) $(BAR)
EOF
close(MAKEFILE);

&run_make_with_options("$makefile2", "", &get_logfile);
$answer = "foo bar\n";
&compare_output($answer, &get_logfile(1));

# TEST #9
# For PR/1380: Using += assignment in target-specific variables sometimes fails
# Also PR/1831

$makefile3 = &get_tmpfile;

open(MAKEFILE,"> $makefile3");
print MAKEFILE <<'EOF';
.PHONY: all one
all: FOO += baz
all: one; @echo $(FOO)

FOO = bar

one: FOO += biz
one: FOO += boz
one: ; @echo $(FOO)
EOF
close(MAKEFILE);

&run_make_with_options("$makefile3", "", &get_logfile);
$answer = "bar baz biz boz\nbar baz\n";
&compare_output($answer, &get_logfile(1));

# Test #10

&run_make_with_options("$makefile3", "one", &get_logfile);
$answer = "bar biz boz\n";
&compare_output($answer, &get_logfile(1));

# Test #11
# PR/1709: Test semicolons in target-specific variable values

$makefile4 = &get_tmpfile;

open(MAKEFILE, "> $makefile4");
print MAKEFILE <<'EOF';
foo : FOO = ; ok
foo : ; @echo '$(FOO)'
EOF
close(MAKEFILE);

&run_make_with_options("$makefile4", "", &get_logfile);
$answer = "; ok\n";
&compare_output($answer, &get_logfile(1));

# Test #12
# PR/2020: More hassles with += target-specific vars.  I _really_ think
# I nailed it this time :-/.

$makefile5 = &get_tmpfile;

open(MAKEFILE, "> $makefile5");
print MAKEFILE <<'EOF';
.PHONY: a

BLAH := foo
COMMAND = echo $(BLAH)

a: ; @$(COMMAND)

a: BLAH := bar
a: COMMAND += snafu $(BLAH)
EOF
close(MAKEFILE);

&run_make_with_options("$makefile5", "", &get_logfile);
$answer = "bar snafu bar\n";
&compare_output($answer, &get_logfile(1));

# Test #13
# Test double-colon rules with target-specific variable values

$makefile6 = &get_tmpfile;

open(MAKEFILE, "> $makefile6");
print MAKEFILE <<'EOF';
W = bad
X = bad
foo: W = ok
foo:: ; @echo $(W) $(X) $(Y) $(Z)
foo:: ; @echo $(W) $(X) $(Y) $(Z)
foo: X = ok

Y = foo
bar: foo
bar: Y = bar

Z = nopat
ifdef PATTERN
  fo% : Z = pat
endif

EOF
close(MAKEFILE);

&run_make_with_options("$makefile6", "foo", &get_logfile);
$answer = "ok ok foo nopat\nok ok foo nopat\n";
&compare_output($answer, &get_logfile(1));

# Test #14
# Test double-colon rules with target-specific variable values and
# inheritance

&run_make_with_options("$makefile6", "bar", &get_logfile);
$answer = "ok ok bar nopat\nok ok bar nopat\n";
&compare_output($answer, &get_logfile(1));

# Test #15
# Test double-colon rules with pattern-specific variable values

&run_make_with_options("$makefile6", "foo PATTERN=yes", &get_logfile);
$answer = "ok ok foo pat\nok ok foo pat\n";
&compare_output($answer, &get_logfile(1));


# Test #16
# Test target-specific variables with very long command line
# (> make default buffer length)

$makefile7 = &get_tmpfile;

open(MAKEFILE, "> $makefile7");
print MAKEFILE <<'EOF';
base_metals_fmd_reports.sun5 base_metals_fmd_reports CreateRealPositions        CreateMarginFunds deals_changed_since : BUILD_OBJ=$(shell if [ -f               "build_information.generate" ]; then echo "$(OBJ_DIR)/build_information.o"; else echo "no build information"; fi  )

deals_changed_since: ; @echo $(BUILD_OBJ)

EOF
close(MAKEFILE);

&run_make_with_options("$makefile7", '', &get_logfile);
$answer = "no build information\n";
&compare_output($answer, &get_logfile(1));

# TEST #17

# Test a merge of set_lists for files, where one list is much longer
# than the other.  See Savannah bug #15757.

mkdir('t1', 0777);
touch('t1/rules.mk');

run_make_test('
VPATH = t1
include rules.mk
.PHONY: all
all: foo.x
foo.x : rules.mk ; @echo MYVAR=$(MYVAR) FOOVAR=$(FOOVAR) ALLVAR=$(ALLVAR)
all: ALLVAR = xxx
foo.x: FOOVAR = bar
rules.mk : MYVAR = foo
.INTERMEDIATE: foo.x rules.mk
',
              '-I t1',
              'MYVAR= FOOVAR=bar ALLVAR=xxx');

rmfiles('t1/rules.mk');
rmdir('t1');

1;