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
|
# $NetBSD: deptgt-makeflags.mk,v 1.9 2023/11/19 22:32:44 rillig Exp $
#
# Tests for the special target .MAKEFLAGS in dependency declarations,
# which adds command line options later, at parse time.
#
# In these unit tests, it is often used to temporarily toggle the debug log
# during parsing.
# The -D option sets a variable in the "Global" scope and thus can be
# undefined later.
.MAKEFLAGS: -D VAR
.if ${VAR} != 1
. error
.endif
# Variables that are set via the -D command line option are normal global
# variables and can thus be undefined later.
.undef VAR
.if defined(VAR)
. error
.endif
# The -D command line option can define a variable again, after it has been
# undefined.
.MAKEFLAGS: -D VAR
.if ${VAR} != 1
. error
.endif
# The "dependency" for .MAKEFLAGS is split into words, interpreting the usual
# quotes and escape sequences from the backslash.
.MAKEFLAGS: VAR="value"' with'\ spaces
.if ${VAR} != "value with spaces"
. error
.endif
# Variables set on the command line as VAR=value are placed in the
# "Command" scope and thus cannot be undefined.
.undef VAR
.if ${VAR} != "value with spaces"
. error
.endif
# When parsing this line, each '$$' becomes '$', resulting in '$$$$'.
# This is assigned to the variable DOLLAR.
# In the condition, that variable is expanded, and at that point, each '$$'
# becomes '$' again, the final expression is thus '$$'.
.MAKEFLAGS: -dcv
.MAKEFLAGS: DOLLAR=$$$$$$$$
.if ${DOLLAR} != "\$\$"
.endif
.MAKEFLAGS: -d0
# An empty command line is skipped.
.MAKEFLAGS: # none
# Escape sequences like \n are interpreted.
# The following line looks as if it assigned a newline to nl, but it doesn't.
# Instead, the \n ends up as a line that is then interpreted as a variable
# assignment. At that point, the line is simply "nl=\n", and the \n is
# skipped since it is whitespace (see Parse_IsVar).
.MAKEFLAGS: nl="\n"
.if ${nl} != ""
. error
.endif
# Next try at defining another newline variable. Since whitespace around the
# variable value is trimmed, two empty expressions ${:U} surround the
# literal newline now. This prevents the newline from being skipped during
# parsing. The ':=' assignment operator expands the empty
# expressions, leaving only the newline as the variable value.
#
# This is one of the very few ways (maybe even the only one) to inject literal
# newlines into a line that is being parsed. This may confuse the parser.
# For example, in cond.c the parser only expects horizontal whitespace (' '
# and '\t'), but no newlines.
#.MAKEFLAGS: -dcpv
.MAKEFLAGS: nl:="$${:U}\n$${:U}"
.if ${nl} != ${.newline}
. error
.endif
#.MAKEFLAGS: -d0
# Now do the same for the other escape sequences; see Substring_Words.
.MAKEFLAGS: CHAR_BS:="$${:U}\b$${:U}"
.MAKEFLAGS: CHAR_FF:="$${:U}\f$${:U}"
.MAKEFLAGS: CHAR_NL:="$${:U}\n$${:U}"
.MAKEFLAGS: CHAR_CR:="$${:U}\r$${:U}"
.MAKEFLAGS: CHAR_TAB:="$${:U}\t$${:U}"
# Note: backspace is not whitespace, it is a control character.
.if ${CHAR_BS:C,^[[:cntrl:]]$,found,W} != "found"
. error
.endif
.if ${CHAR_FF:C,^[[:space:]]$,found,W} != "found"
. error
.endif
.if ${CHAR_NL:C,^[[:space:]]$,found,W} != "found"
. error
.endif
.if ${CHAR_CR:C,^[[:space:]]$,found,W} != "found"
. error
.endif
.if ${CHAR_TAB:C,^[[:space:]]$,found,W} != "found"
. error
.endif
# Unbalanced quotes produce an error message. If they occur anywhere in the
# command line, the whole command line is skipped.
.MAKEFLAGS: VAR=previous
.MAKEFLAGS: VAR=initial UNBALANCED='
.if ${VAR} != "previous"
. error
.endif
all:
@:;
|
