cond.c revision 1.324 1 1.324 rillig /* $NetBSD: cond.c,v 1.324 2022/01/07 09:19:43 rillig Exp $ */
2 1.6 christos
3 1.1 cgd /*
4 1.1 cgd * Copyright (c) 1988, 1989, 1990 The Regents of the University of California.
5 1.17 agc * All rights reserved.
6 1.17 agc *
7 1.17 agc * This code is derived from software contributed to Berkeley by
8 1.17 agc * Adam de Boor.
9 1.17 agc *
10 1.17 agc * Redistribution and use in source and binary forms, with or without
11 1.17 agc * modification, are permitted provided that the following conditions
12 1.17 agc * are met:
13 1.17 agc * 1. Redistributions of source code must retain the above copyright
14 1.17 agc * notice, this list of conditions and the following disclaimer.
15 1.17 agc * 2. Redistributions in binary form must reproduce the above copyright
16 1.17 agc * notice, this list of conditions and the following disclaimer in the
17 1.17 agc * documentation and/or other materials provided with the distribution.
18 1.17 agc * 3. Neither the name of the University nor the names of its contributors
19 1.17 agc * may be used to endorse or promote products derived from this software
20 1.17 agc * without specific prior written permission.
21 1.17 agc *
22 1.17 agc * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
23 1.17 agc * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
24 1.17 agc * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
25 1.17 agc * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
26 1.17 agc * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
27 1.17 agc * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
28 1.17 agc * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
29 1.17 agc * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
30 1.17 agc * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
31 1.17 agc * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
32 1.17 agc * SUCH DAMAGE.
33 1.17 agc */
34 1.17 agc
35 1.17 agc /*
36 1.1 cgd * Copyright (c) 1988, 1989 by Adam de Boor
37 1.1 cgd * Copyright (c) 1989 by Berkeley Softworks
38 1.1 cgd * All rights reserved.
39 1.1 cgd *
40 1.1 cgd * This code is derived from software contributed to Berkeley by
41 1.1 cgd * Adam de Boor.
42 1.1 cgd *
43 1.1 cgd * Redistribution and use in source and binary forms, with or without
44 1.1 cgd * modification, are permitted provided that the following conditions
45 1.1 cgd * are met:
46 1.1 cgd * 1. Redistributions of source code must retain the above copyright
47 1.1 cgd * notice, this list of conditions and the following disclaimer.
48 1.1 cgd * 2. Redistributions in binary form must reproduce the above copyright
49 1.1 cgd * notice, this list of conditions and the following disclaimer in the
50 1.1 cgd * documentation and/or other materials provided with the distribution.
51 1.1 cgd * 3. All advertising materials mentioning features or use of this software
52 1.1 cgd * must display the following acknowledgement:
53 1.1 cgd * This product includes software developed by the University of
54 1.1 cgd * California, Berkeley and its contributors.
55 1.1 cgd * 4. Neither the name of the University nor the names of its contributors
56 1.1 cgd * may be used to endorse or promote products derived from this software
57 1.1 cgd * without specific prior written permission.
58 1.1 cgd *
59 1.1 cgd * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
60 1.1 cgd * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
61 1.1 cgd * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
62 1.1 cgd * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
63 1.1 cgd * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
64 1.1 cgd * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
65 1.1 cgd * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
66 1.1 cgd * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
67 1.1 cgd * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
68 1.1 cgd * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
69 1.1 cgd * SUCH DAMAGE.
70 1.1 cgd */
71 1.1 cgd
72 1.233 rillig /*
73 1.233 rillig * Handling of conditionals in a makefile.
74 1.1 cgd *
75 1.1 cgd * Interface:
76 1.209 rillig * Cond_EvalLine Evaluate the conditional directive, such as
77 1.209 rillig * '.if <cond>', '.elifnmake <cond>', '.else', '.endif'.
78 1.1 cgd *
79 1.142 rillig * Cond_EvalCondition
80 1.168 rillig * Evaluate the conditional, which is either the argument
81 1.168 rillig * of one of the .if directives or the condition in a
82 1.168 rillig * ':?then:else' variable modifier.
83 1.117 rillig *
84 1.117 rillig * Cond_save_depth
85 1.117 rillig * Cond_restore_depth
86 1.117 rillig * Save and restore the nesting of the conditions, at
87 1.117 rillig * the start and end of including another makefile, to
88 1.117 rillig * ensure that in each makefile the conditional
89 1.117 rillig * directives are well-balanced.
90 1.1 cgd */
91 1.1 cgd
92 1.99 rillig #include <errno.h>
93 1.99 rillig
94 1.99 rillig #include "make.h"
95 1.99 rillig #include "dir.h"
96 1.1 cgd
97 1.144 rillig /* "@(#)cond.c 8.2 (Berkeley) 1/2/94" */
98 1.324 rillig MAKE_RCSID("$NetBSD: cond.c,v 1.324 2022/01/07 09:19:43 rillig Exp $");
99 1.144 rillig
100 1.1 cgd /*
101 1.324 rillig * Conditional expressions conform to this grammar:
102 1.285 rillig * Or -> And ('||' And)*
103 1.288 rillig * And -> Term ('&&' Term)*
104 1.239 rillig * Term -> Function '(' Argument ')'
105 1.239 rillig * Term -> Leaf Operator Leaf
106 1.239 rillig * Term -> Leaf
107 1.239 rillig * Term -> '(' Or ')'
108 1.239 rillig * Term -> '!' Term
109 1.239 rillig * Leaf -> "string"
110 1.239 rillig * Leaf -> Number
111 1.239 rillig * Leaf -> VariableExpression
112 1.324 rillig * Leaf -> BareWord
113 1.239 rillig * Operator -> '==' | '!=' | '>' | '<' | '>=' | '<='
114 1.1 cgd *
115 1.324 rillig * BareWord is an unquoted string literal, its evaluation depends on the kind
116 1.324 rillig * of '.if' directive.
117 1.1 cgd *
118 1.324 rillig * The tokens are scanned by CondParser_Token, which returns:
119 1.239 rillig * TOK_AND for '&&'
120 1.239 rillig * TOK_OR for '||'
121 1.121 rillig * TOK_NOT for '!'
122 1.121 rillig * TOK_LPAREN for '('
123 1.121 rillig * TOK_RPAREN for ')'
124 1.239 rillig *
125 1.121 rillig * Other terminal symbols are evaluated using either the default function or
126 1.307 rillig * the function given in the terminal, they return either TOK_TRUE, TOK_FALSE
127 1.307 rillig * or TOK_ERROR.
128 1.1 cgd */
129 1.164 rillig typedef enum Token {
130 1.241 rillig TOK_FALSE, TOK_TRUE, TOK_AND, TOK_OR, TOK_NOT,
131 1.215 rillig TOK_LPAREN, TOK_RPAREN, TOK_EOF, TOK_NONE, TOK_ERROR
132 1.1 cgd } Token;
133 1.1 cgd
134 1.251 rillig typedef enum ComparisonOp {
135 1.251 rillig LT, LE, GT, GE, EQ, NE
136 1.251 rillig } ComparisonOp;
137 1.251 rillig
138 1.150 rillig typedef struct CondParser {
139 1.243 rillig
140 1.243 rillig /*
141 1.243 rillig * The plain '.if ${VAR}' evaluates to true if the value of the
142 1.243 rillig * expression has length > 0. The other '.if' variants delegate
143 1.243 rillig * to evalBare instead.
144 1.243 rillig */
145 1.260 rillig bool plain;
146 1.243 rillig
147 1.243 rillig /* The function to apply on unquoted bare words. */
148 1.297 rillig bool (*evalBare)(const char *);
149 1.260 rillig bool negateEvalBare;
150 1.243 rillig
151 1.276 rillig /*
152 1.277 rillig * Whether the left-hand side of a comparison may be an unquoted
153 1.276 rillig * string. This is allowed for expressions of the form
154 1.276 rillig * ${condition:?:}, see ApplyModifier_IfElse. Such a condition is
155 1.276 rillig * expanded before it is evaluated, due to ease of implementation.
156 1.276 rillig * This means that at the point where the condition is evaluated,
157 1.276 rillig * make cannot know anymore whether the left-hand side had originally
158 1.276 rillig * been a variable expression or a plain word.
159 1.276 rillig *
160 1.276 rillig * In all other contexts, the left-hand side must either be a
161 1.276 rillig * variable expression, a quoted string or a number.
162 1.276 rillig */
163 1.277 rillig bool leftUnquotedOK;
164 1.276 rillig
165 1.215 rillig const char *p; /* The remaining condition to parse */
166 1.215 rillig Token curr; /* Single push-back token used in parsing */
167 1.215 rillig
168 1.215 rillig /*
169 1.215 rillig * Whether an error message has already been printed for this
170 1.215 rillig * condition. The first available error message is usually the most
171 1.215 rillig * specific one, therefore it makes sense to suppress the standard
172 1.215 rillig * "Malformed conditional" message.
173 1.215 rillig */
174 1.260 rillig bool printedError;
175 1.121 rillig } CondParser;
176 1.1 cgd
177 1.260 rillig static CondResult CondParser_Or(CondParser *par, bool);
178 1.1 cgd
179 1.93 rillig static unsigned int cond_depth = 0; /* current .if nesting level */
180 1.93 rillig static unsigned int cond_min_depth = 0; /* depth at makefile open */
181 1.1 cgd
182 1.268 rillig /* Names for ComparisonOp. */
183 1.278 rillig static const char opname[][3] = { "<", "<=", ">", ">=", "==", "!=" };
184 1.251 rillig
185 1.314 rillig MAKE_INLINE bool
186 1.314 rillig skip_string(const char **pp, const char *str)
187 1.26 christos {
188 1.314 rillig size_t len = strlen(str);
189 1.314 rillig bool ok = strncmp(*pp, str, len) == 0;
190 1.314 rillig if (ok)
191 1.314 rillig *pp += len;
192 1.314 rillig return ok;
193 1.26 christos }
194 1.26 christos
195 1.183 rillig static Token
196 1.260 rillig ToToken(bool cond)
197 1.183 rillig {
198 1.215 rillig return cond ? TOK_TRUE : TOK_FALSE;
199 1.183 rillig }
200 1.183 rillig
201 1.116 rillig static void
202 1.121 rillig CondParser_SkipWhitespace(CondParser *par)
203 1.116 rillig {
204 1.215 rillig cpp_skip_whitespace(&par->p);
205 1.116 rillig }
206 1.116 rillig
207 1.233 rillig /*
208 1.301 rillig * Parse a single word, taking into account balanced parentheses as well as
209 1.301 rillig * embedded expressions. Used for the argument of a built-in function as
210 1.301 rillig * well as for bare words, which are then passed to the default function.
211 1.233 rillig */
212 1.318 rillig static char *
213 1.319 rillig ParseWord(const char **pp, bool doEval)
214 1.215 rillig {
215 1.215 rillig const char *p = *pp;
216 1.215 rillig Buffer argBuf;
217 1.215 rillig int paren_depth;
218 1.215 rillig
219 1.215 rillig Buf_InitSize(&argBuf, 16);
220 1.215 rillig
221 1.215 rillig paren_depth = 0;
222 1.215 rillig for (;;) {
223 1.215 rillig char ch = *p;
224 1.215 rillig if (ch == '\0' || ch == ' ' || ch == '\t')
225 1.215 rillig break;
226 1.215 rillig if ((ch == '&' || ch == '|') && paren_depth == 0)
227 1.215 rillig break;
228 1.322 rillig if (ch == '$') {
229 1.215 rillig /*
230 1.215 rillig * Parse the variable expression and install it as
231 1.215 rillig * part of the argument if it's valid. We tell
232 1.215 rillig * Var_Parse to complain on an undefined variable,
233 1.215 rillig * (XXX: but Var_Parse ignores that request)
234 1.215 rillig * so we don't need to do it. Nor do we return an
235 1.215 rillig * error, though perhaps we should.
236 1.215 rillig */
237 1.261 rillig VarEvalMode emode = doEval
238 1.259 rillig ? VARE_UNDEFERR
239 1.258 rillig : VARE_PARSE_ONLY;
240 1.229 rillig FStr nestedVal;
241 1.261 rillig (void)Var_Parse(&p, SCOPE_CMDLINE, emode, &nestedVal);
242 1.215 rillig /* TODO: handle errors */
243 1.229 rillig Buf_AddStr(&argBuf, nestedVal.str);
244 1.229 rillig FStr_Done(&nestedVal);
245 1.215 rillig continue;
246 1.215 rillig }
247 1.215 rillig if (ch == '(')
248 1.215 rillig paren_depth++;
249 1.215 rillig else if (ch == ')' && --paren_depth < 0)
250 1.215 rillig break;
251 1.322 rillig Buf_AddByte(&argBuf, ch);
252 1.215 rillig p++;
253 1.215 rillig }
254 1.50 dsl
255 1.319 rillig cpp_skip_hspace(&p);
256 1.319 rillig *pp = p;
257 1.215 rillig
258 1.319 rillig return Buf_DoneData(&argBuf);
259 1.319 rillig }
260 1.319 rillig
261 1.319 rillig /* Parse the function argument, including the surrounding parentheses. */
262 1.319 rillig static char *
263 1.319 rillig ParseFuncArg(CondParser *par, const char **pp, bool doEval, const char *func)
264 1.319 rillig {
265 1.319 rillig const char *p = *pp;
266 1.319 rillig char *res;
267 1.319 rillig
268 1.319 rillig p++; /* Skip opening '(' - verified by caller */
269 1.319 rillig cpp_skip_hspace(&p);
270 1.319 rillig res = ParseWord(&p, doEval);
271 1.215 rillig cpp_skip_hspace(&p);
272 1.215 rillig
273 1.319 rillig if (*p++ != ')') {
274 1.314 rillig int len = 0;
275 1.314 rillig while (ch_isalpha(func[len]))
276 1.314 rillig len++;
277 1.314 rillig
278 1.253 rillig Parse_Error(PARSE_FATAL,
279 1.314 rillig "Missing closing parenthesis for %.*s()", len, func);
280 1.260 rillig par->printedError = true;
281 1.318 rillig free(res);
282 1.318 rillig return NULL;
283 1.215 rillig }
284 1.215 rillig
285 1.215 rillig *pp = p;
286 1.318 rillig return res;
287 1.1 cgd }
288 1.90 rillig
289 1.90 rillig /* Test whether the given variable is defined. */
290 1.260 rillig static bool
291 1.324 rillig FuncDefined(const char *var)
292 1.1 cgd {
293 1.324 rillig FStr value = Var_Value(SCOPE_CMDLINE, var);
294 1.260 rillig bool result = value.str != NULL;
295 1.230 rillig FStr_Done(&value);
296 1.215 rillig return result;
297 1.1 cgd }
298 1.90 rillig
299 1.268 rillig /* See if the given target is requested to be made. */
300 1.260 rillig static bool
301 1.324 rillig FuncMake(const char *target)
302 1.1 cgd {
303 1.215 rillig StringListNode *ln;
304 1.166 rillig
305 1.219 rillig for (ln = opts.create.first; ln != NULL; ln = ln->next)
306 1.324 rillig if (Str_Match(ln->datum, target))
307 1.260 rillig return true;
308 1.260 rillig return false;
309 1.1 cgd }
310 1.90 rillig
311 1.90 rillig /* See if the given file exists. */
312 1.260 rillig static bool
313 1.324 rillig FuncExists(const char *file)
314 1.1 cgd {
315 1.260 rillig bool result;
316 1.215 rillig char *path;
317 1.1 cgd
318 1.324 rillig path = Dir_FindFile(file, &dirSearchPath);
319 1.215 rillig DEBUG2(COND, "exists(%s) result is \"%s\"\n",
320 1.324 rillig file, path != NULL ? path : "");
321 1.215 rillig result = path != NULL;
322 1.215 rillig free(path);
323 1.215 rillig return result;
324 1.1 cgd }
325 1.90 rillig
326 1.90 rillig /* See if the given node exists and is an actual target. */
327 1.260 rillig static bool
328 1.324 rillig FuncTarget(const char *node)
329 1.1 cgd {
330 1.324 rillig GNode *gn = Targ_FindNode(node);
331 1.215 rillig return gn != NULL && GNode_IsTarget(gn);
332 1.1 cgd }
333 1.1 cgd
334 1.233 rillig /*
335 1.233 rillig * See if the given node exists and is an actual target with commands
336 1.233 rillig * associated with it.
337 1.233 rillig */
338 1.260 rillig static bool
339 1.324 rillig FuncCommands(const char *node)
340 1.12 christos {
341 1.324 rillig GNode *gn = Targ_FindNode(node);
342 1.324 rillig return gn != NULL && GNode_IsTarget(gn) &&
343 1.324 rillig !Lst_IsEmpty(&gn->commands);
344 1.12 christos }
345 1.90 rillig
346 1.189 rillig /*
347 1.324 rillig * Convert the string into a floating-point number. Accepted formats are
348 1.324 rillig * base-10 integer, base-16 integer and finite floating point numbers.
349 1.1 cgd */
350 1.260 rillig static bool
351 1.189 rillig TryParseNumber(const char *str, double *out_value)
352 1.1 cgd {
353 1.215 rillig char *end;
354 1.215 rillig unsigned long ul_val;
355 1.215 rillig double dbl_val;
356 1.215 rillig
357 1.215 rillig if (str[0] == '\0') { /* XXX: why is an empty string a number? */
358 1.215 rillig *out_value = 0.0;
359 1.260 rillig return true;
360 1.215 rillig }
361 1.189 rillig
362 1.270 rillig errno = 0;
363 1.215 rillig ul_val = strtoul(str, &end, str[1] == 'x' ? 16 : 10);
364 1.215 rillig if (*end == '\0' && errno != ERANGE) {
365 1.215 rillig *out_value = str[0] == '-' ? -(double)-ul_val : (double)ul_val;
366 1.260 rillig return true;
367 1.215 rillig }
368 1.46 dsl
369 1.215 rillig if (*end != '\0' && *end != '.' && *end != 'e' && *end != 'E')
370 1.260 rillig return false; /* skip the expensive strtod call */
371 1.215 rillig dbl_val = strtod(str, &end);
372 1.215 rillig if (*end != '\0')
373 1.260 rillig return false;
374 1.189 rillig
375 1.215 rillig *out_value = dbl_val;
376 1.260 rillig return true;
377 1.1 cgd }
378 1.46 dsl
379 1.260 rillig static bool
380 1.140 rillig is_separator(char ch)
381 1.140 rillig {
382 1.267 rillig return ch == '\0' || ch_isspace(ch) || ch == '!' || ch == '=' ||
383 1.267 rillig ch == '>' || ch == '<' || ch == ')' /* but not '(' */;
384 1.140 rillig }
385 1.140 rillig
386 1.242 rillig /*
387 1.248 rillig * In a quoted or unquoted string literal or a number, parse a variable
388 1.248 rillig * expression.
389 1.248 rillig *
390 1.248 rillig * Example: .if x${CENTER}y == "${PREFIX}${SUFFIX}" || 0x${HEX}
391 1.248 rillig */
392 1.260 rillig static bool
393 1.248 rillig CondParser_StringExpr(CondParser *par, const char *start,
394 1.274 rillig bool doEval, bool quoted,
395 1.274 rillig Buffer *buf, FStr *inout_str)
396 1.248 rillig {
397 1.261 rillig VarEvalMode emode;
398 1.308 rillig const char *p;
399 1.260 rillig bool atStart;
400 1.248 rillig VarParseResult parseResult;
401 1.248 rillig
402 1.275 rillig emode = doEval && quoted ? VARE_WANTRES
403 1.275 rillig : doEval ? VARE_UNDEFERR
404 1.258 rillig : VARE_PARSE_ONLY;
405 1.248 rillig
406 1.308 rillig p = par->p;
407 1.308 rillig atStart = p == start;
408 1.308 rillig parseResult = Var_Parse(&p, SCOPE_CMDLINE, emode, inout_str);
409 1.248 rillig /* TODO: handle errors */
410 1.248 rillig if (inout_str->str == var_Error) {
411 1.248 rillig if (parseResult == VPR_ERR) {
412 1.248 rillig /*
413 1.249 rillig * FIXME: Even if an error occurs, there is no
414 1.249 rillig * guarantee that it is reported.
415 1.248 rillig *
416 1.248 rillig * See cond-token-plain.mk $$$$$$$$.
417 1.248 rillig */
418 1.260 rillig par->printedError = true;
419 1.248 rillig }
420 1.248 rillig /*
421 1.249 rillig * XXX: Can there be any situation in which a returned
422 1.257 rillig * var_Error needs to be freed?
423 1.248 rillig */
424 1.248 rillig FStr_Done(inout_str);
425 1.248 rillig /*
426 1.249 rillig * Even if !doEval, we still report syntax errors, which is
427 1.249 rillig * what getting var_Error back with !doEval means.
428 1.248 rillig */
429 1.248 rillig *inout_str = FStr_InitRefer(NULL);
430 1.260 rillig return false;
431 1.248 rillig }
432 1.308 rillig par->p = p;
433 1.248 rillig
434 1.248 rillig /*
435 1.249 rillig * If the '$' started the string literal (which means no quotes), and
436 1.249 rillig * the variable expression is followed by a space, looks like a
437 1.249 rillig * comparison operator or is the end of the expression, we are done.
438 1.248 rillig */
439 1.248 rillig if (atStart && is_separator(par->p[0]))
440 1.260 rillig return false;
441 1.248 rillig
442 1.248 rillig Buf_AddStr(buf, inout_str->str);
443 1.248 rillig FStr_Done(inout_str);
444 1.306 rillig *inout_str = FStr_InitRefer(NULL); /* not finished yet */
445 1.260 rillig return true;
446 1.248 rillig }
447 1.248 rillig
448 1.248 rillig /*
449 1.307 rillig * Parse a string from a variable expression or an optionally quoted string,
450 1.307 rillig * on the left-hand and right-hand sides of comparisons.
451 1.23 sjg *
452 1.23 sjg * Results:
453 1.307 rillig * Returns the string without any enclosing quotes, or NULL on error.
454 1.266 rillig * Sets out_quoted if the leaf was a quoted string literal.
455 1.23 sjg */
456 1.227 rillig static void
457 1.277 rillig CondParser_Leaf(CondParser *par, bool doEval, bool unquotedOK,
458 1.260 rillig FStr *out_str, bool *out_quoted)
459 1.23 sjg {
460 1.215 rillig Buffer buf;
461 1.228 rillig FStr str;
462 1.260 rillig bool quoted;
463 1.215 rillig const char *start;
464 1.215 rillig
465 1.215 rillig Buf_Init(&buf);
466 1.228 rillig str = FStr_InitRefer(NULL);
467 1.215 rillig *out_quoted = quoted = par->p[0] == '"';
468 1.215 rillig start = par->p;
469 1.215 rillig if (quoted)
470 1.122 rillig par->p++;
471 1.227 rillig
472 1.228 rillig while (par->p[0] != '\0' && str.str == NULL) {
473 1.215 rillig switch (par->p[0]) {
474 1.215 rillig case '\\':
475 1.215 rillig par->p++;
476 1.215 rillig if (par->p[0] != '\0') {
477 1.215 rillig Buf_AddByte(&buf, par->p[0]);
478 1.215 rillig par->p++;
479 1.215 rillig }
480 1.215 rillig continue;
481 1.215 rillig case '"':
482 1.215 rillig par->p++;
483 1.246 rillig if (quoted)
484 1.246 rillig goto got_str; /* skip the closing quote */
485 1.246 rillig Buf_AddByte(&buf, '"');
486 1.215 rillig continue;
487 1.215 rillig case ')': /* see is_separator */
488 1.215 rillig case '!':
489 1.215 rillig case '=':
490 1.215 rillig case '>':
491 1.215 rillig case '<':
492 1.215 rillig case ' ':
493 1.215 rillig case '\t':
494 1.215 rillig if (!quoted)
495 1.215 rillig goto got_str;
496 1.215 rillig Buf_AddByte(&buf, par->p[0]);
497 1.215 rillig par->p++;
498 1.215 rillig continue;
499 1.215 rillig case '$':
500 1.248 rillig if (!CondParser_StringExpr(par,
501 1.248 rillig start, doEval, quoted, &buf, &str))
502 1.215 rillig goto cleanup;
503 1.215 rillig continue;
504 1.215 rillig default:
505 1.277 rillig if (!unquotedOK && !quoted && *start != '$' &&
506 1.215 rillig !ch_isdigit(*start)) {
507 1.215 rillig /*
508 1.215 rillig * The left-hand side must be quoted,
509 1.277 rillig * a variable expression or a number.
510 1.215 rillig */
511 1.228 rillig str = FStr_InitRefer(NULL);
512 1.215 rillig goto cleanup;
513 1.215 rillig }
514 1.215 rillig Buf_AddByte(&buf, par->p[0]);
515 1.215 rillig par->p++;
516 1.215 rillig continue;
517 1.30 christos }
518 1.23 sjg }
519 1.93 rillig got_str:
520 1.254 rillig str = FStr_InitOwn(buf.data);
521 1.303 rillig buf.data = NULL;
522 1.93 rillig cleanup:
523 1.303 rillig Buf_Done(&buf);
524 1.227 rillig *out_str = str;
525 1.23 sjg }
526 1.89 rillig
527 1.260 rillig static bool
528 1.297 rillig EvalBare(const CondParser *par, const char *arg)
529 1.176 rillig {
530 1.297 rillig bool res = par->evalBare(arg);
531 1.243 rillig return par->negateEvalBare ? !res : res;
532 1.176 rillig }
533 1.176 rillig
534 1.233 rillig /*
535 1.233 rillig * Evaluate a "comparison without operator", such as in ".if ${VAR}" or
536 1.233 rillig * ".if 0".
537 1.233 rillig */
538 1.260 rillig static bool
539 1.260 rillig EvalNotEmpty(CondParser *par, const char *value, bool quoted)
540 1.131 rillig {
541 1.215 rillig double num;
542 1.131 rillig
543 1.215 rillig /* For .ifxxx "...", check for non-empty string. */
544 1.215 rillig if (quoted)
545 1.215 rillig return value[0] != '\0';
546 1.215 rillig
547 1.215 rillig /* For .ifxxx <number>, compare against zero */
548 1.215 rillig if (TryParseNumber(value, &num))
549 1.215 rillig return num != 0.0;
550 1.215 rillig
551 1.306 rillig /*
552 1.306 rillig * For .if ${...}, check for non-empty string. This is different
553 1.306 rillig * from the evaluation function from that .if variant, which would
554 1.306 rillig * test whether a variable of the given name were defined.
555 1.306 rillig */
556 1.295 rillig /*
557 1.295 rillig * XXX: Whitespace should count as empty, just as in
558 1.295 rillig * CondParser_FuncCallEmpty.
559 1.295 rillig */
560 1.243 rillig if (par->plain)
561 1.215 rillig return value[0] != '\0';
562 1.131 rillig
563 1.297 rillig return EvalBare(par, value);
564 1.131 rillig }
565 1.131 rillig
566 1.133 rillig /* Evaluate a numerical comparison, such as in ".if ${VAR} >= 9". */
567 1.260 rillig static bool
568 1.251 rillig EvalCompareNum(double lhs, ComparisonOp op, double rhs)
569 1.130 rillig {
570 1.251 rillig DEBUG3(COND, "lhs = %f, rhs = %f, op = %.2s\n", lhs, rhs, opname[op]);
571 1.130 rillig
572 1.251 rillig switch (op) {
573 1.251 rillig case LT:
574 1.251 rillig return lhs < rhs;
575 1.251 rillig case LE:
576 1.251 rillig return lhs <= rhs;
577 1.251 rillig case GT:
578 1.251 rillig return lhs > rhs;
579 1.251 rillig case GE:
580 1.251 rillig return lhs >= rhs;
581 1.251 rillig case NE:
582 1.251 rillig return lhs != rhs;
583 1.251 rillig default:
584 1.251 rillig return lhs == rhs;
585 1.215 rillig }
586 1.130 rillig }
587 1.130 rillig
588 1.133 rillig static Token
589 1.252 rillig EvalCompareStr(CondParser *par, const char *lhs,
590 1.252 rillig ComparisonOp op, const char *rhs)
591 1.133 rillig {
592 1.251 rillig if (op != EQ && op != NE) {
593 1.252 rillig Parse_Error(PARSE_FATAL,
594 1.251 rillig "String comparison operator must be either == or !=");
595 1.260 rillig par->printedError = true;
596 1.215 rillig return TOK_ERROR;
597 1.215 rillig }
598 1.133 rillig
599 1.251 rillig DEBUG3(COND, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n",
600 1.251 rillig lhs, rhs, opname[op]);
601 1.251 rillig return ToToken((op == EQ) == (strcmp(lhs, rhs) == 0));
602 1.133 rillig }
603 1.133 rillig
604 1.133 rillig /* Evaluate a comparison, such as "${VAR} == 12345". */
605 1.133 rillig static Token
606 1.260 rillig EvalCompare(CondParser *par, const char *lhs, bool lhsQuoted,
607 1.260 rillig ComparisonOp op, const char *rhs, bool rhsQuoted)
608 1.133 rillig {
609 1.215 rillig double left, right;
610 1.133 rillig
611 1.215 rillig if (!rhsQuoted && !lhsQuoted)
612 1.215 rillig if (TryParseNumber(lhs, &left) && TryParseNumber(rhs, &right))
613 1.251 rillig return ToToken(EvalCompareNum(left, op, right));
614 1.133 rillig
615 1.252 rillig return EvalCompareStr(par, lhs, op, rhs);
616 1.133 rillig }
617 1.133 rillig
618 1.260 rillig static bool
619 1.251 rillig CondParser_ComparisonOp(CondParser *par, ComparisonOp *out_op)
620 1.251 rillig {
621 1.251 rillig const char *p = par->p;
622 1.251 rillig
623 1.304 rillig if (p[0] == '<' && p[1] == '=')
624 1.304 rillig return par->p += 2, *out_op = LE, true;
625 1.304 rillig if (p[0] == '<')
626 1.304 rillig return par->p += 1, *out_op = LT, true;
627 1.304 rillig if (p[0] == '>' && p[1] == '=')
628 1.304 rillig return par->p += 2, *out_op = GE, true;
629 1.304 rillig if (p[0] == '>')
630 1.304 rillig return par->p += 1, *out_op = GT, true;
631 1.304 rillig if (p[0] == '=' && p[1] == '=')
632 1.304 rillig return par->p += 2, *out_op = EQ, true;
633 1.304 rillig if (p[0] == '!' && p[1] == '=')
634 1.304 rillig return par->p += 2, *out_op = NE, true;
635 1.260 rillig return false;
636 1.251 rillig }
637 1.251 rillig
638 1.233 rillig /*
639 1.233 rillig * Parse a comparison condition such as:
640 1.129 rillig *
641 1.129 rillig * 0
642 1.129 rillig * ${VAR:Mpattern}
643 1.129 rillig * ${VAR} == value
644 1.129 rillig * ${VAR:U0} < 12345
645 1.129 rillig */
646 1.1 cgd static Token
647 1.260 rillig CondParser_Comparison(CondParser *par, bool doEval)
648 1.44 dsl {
649 1.215 rillig Token t = TOK_ERROR;
650 1.228 rillig FStr lhs, rhs;
651 1.251 rillig ComparisonOp op;
652 1.260 rillig bool lhsQuoted, rhsQuoted;
653 1.215 rillig
654 1.277 rillig CondParser_Leaf(par, doEval, par->leftUnquotedOK, &lhs, &lhsQuoted);
655 1.228 rillig if (lhs.str == NULL)
656 1.215 rillig goto done_lhs;
657 1.215 rillig
658 1.215 rillig CondParser_SkipWhitespace(par);
659 1.215 rillig
660 1.251 rillig if (!CondParser_ComparisonOp(par, &op)) {
661 1.215 rillig /* Unknown operator, compare against an empty string or 0. */
662 1.228 rillig t = ToToken(doEval && EvalNotEmpty(par, lhs.str, lhsQuoted));
663 1.215 rillig goto done_lhs;
664 1.215 rillig }
665 1.215 rillig
666 1.215 rillig CondParser_SkipWhitespace(par);
667 1.215 rillig
668 1.215 rillig if (par->p[0] == '\0') {
669 1.252 rillig Parse_Error(PARSE_FATAL,
670 1.269 rillig "Missing right-hand side of operator '%s'", opname[op]);
671 1.260 rillig par->printedError = true;
672 1.215 rillig goto done_lhs;
673 1.215 rillig }
674 1.215 rillig
675 1.277 rillig CondParser_Leaf(par, doEval, true, &rhs, &rhsQuoted);
676 1.228 rillig if (rhs.str == NULL)
677 1.215 rillig goto done_rhs;
678 1.215 rillig
679 1.215 rillig if (!doEval) {
680 1.215 rillig t = TOK_FALSE;
681 1.215 rillig goto done_rhs;
682 1.215 rillig }
683 1.79 sjg
684 1.252 rillig t = EvalCompare(par, lhs.str, lhsQuoted, op, rhs.str, rhsQuoted);
685 1.58 dsl
686 1.185 rillig done_rhs:
687 1.228 rillig FStr_Done(&rhs);
688 1.185 rillig done_lhs:
689 1.228 rillig FStr_Done(&lhs);
690 1.215 rillig return t;
691 1.44 dsl }
692 1.44 dsl
693 1.233 rillig /*
694 1.233 rillig * The argument to empty() is a variable name, optionally followed by
695 1.233 rillig * variable modifiers.
696 1.233 rillig */
697 1.295 rillig static bool
698 1.295 rillig CondParser_FuncCallEmpty(CondParser *par, bool doEval, Token *out_token)
699 1.47 dsl {
700 1.295 rillig const char *cp = par->p;
701 1.295 rillig Token tok;
702 1.229 rillig FStr val;
703 1.215 rillig
704 1.314 rillig if (!skip_string(&cp, "empty"))
705 1.295 rillig return false;
706 1.295 rillig
707 1.295 rillig cpp_skip_whitespace(&cp);
708 1.295 rillig if (*cp != '(')
709 1.295 rillig return false;
710 1.295 rillig
711 1.295 rillig cp--; /* Make cp[1] point to the '('. */
712 1.295 rillig (void)Var_Parse(&cp, SCOPE_CMDLINE,
713 1.258 rillig doEval ? VARE_WANTRES : VARE_PARSE_ONLY, &val);
714 1.215 rillig /* TODO: handle errors */
715 1.215 rillig
716 1.293 rillig if (val.str == var_Error)
717 1.293 rillig tok = TOK_ERROR;
718 1.293 rillig else {
719 1.293 rillig cpp_skip_whitespace(&val.str);
720 1.317 rillig tok = ToToken(doEval && val.str[0] == '\0');
721 1.215 rillig }
722 1.215 rillig
723 1.229 rillig FStr_Done(&val);
724 1.294 rillig *out_token = tok;
725 1.290 rillig par->p = cp;
726 1.290 rillig return true;
727 1.290 rillig }
728 1.290 rillig
729 1.263 rillig /* Parse a function call expression, such as 'defined(${file})'. */
730 1.260 rillig static bool
731 1.263 rillig CondParser_FuncCall(CondParser *par, bool doEval, Token *out_token)
732 1.44 dsl {
733 1.318 rillig char *arg;
734 1.314 rillig const char *p = par->p;
735 1.314 rillig bool (*fn)(const char *);
736 1.314 rillig const char *fn_name = p;
737 1.215 rillig
738 1.314 rillig if (skip_string(&p, "defined"))
739 1.314 rillig fn = FuncDefined;
740 1.314 rillig else if (skip_string(&p, "make"))
741 1.314 rillig fn = FuncMake;
742 1.314 rillig else if (skip_string(&p, "exists"))
743 1.314 rillig fn = FuncExists;
744 1.314 rillig else if (skip_string(&p, "target"))
745 1.314 rillig fn = FuncTarget;
746 1.314 rillig else if (skip_string(&p, "commands"))
747 1.314 rillig fn = FuncCommands;
748 1.314 rillig else
749 1.314 rillig return false;
750 1.272 rillig
751 1.314 rillig cpp_skip_whitespace(&p);
752 1.314 rillig if (*p != '(')
753 1.272 rillig return false;
754 1.215 rillig
755 1.319 rillig arg = ParseFuncArg(par, &p, doEval, fn_name);
756 1.319 rillig *out_token = ToToken(doEval &&
757 1.319 rillig arg != NULL && arg[0] != '\0' && fn(arg));
758 1.318 rillig free(arg);
759 1.200 rillig
760 1.314 rillig par->p = p;
761 1.272 rillig return true;
762 1.196 rillig }
763 1.196 rillig
764 1.233 rillig /*
765 1.302 rillig * Parse a comparison that neither starts with '"' nor '$', such as the
766 1.302 rillig * unusual 'bare == right' or '3 == ${VAR}', or a simple leaf without
767 1.266 rillig * operator, which is a number, a variable expression or a string literal.
768 1.302 rillig *
769 1.302 rillig * TODO: Can this be merged into CondParser_Comparison?
770 1.233 rillig */
771 1.196 rillig static Token
772 1.266 rillig CondParser_ComparisonOrLeaf(CondParser *par, bool doEval)
773 1.196 rillig {
774 1.215 rillig Token t;
775 1.323 rillig char *arg;
776 1.221 rillig const char *cp;
777 1.215 rillig
778 1.215 rillig /* Push anything numeric through the compare expression */
779 1.215 rillig cp = par->p;
780 1.215 rillig if (ch_isdigit(cp[0]) || cp[0] == '-' || cp[0] == '+')
781 1.215 rillig return CondParser_Comparison(par, doEval);
782 1.196 rillig
783 1.215 rillig /*
784 1.215 rillig * Most likely we have a naked token to apply the default function to.
785 1.215 rillig * However ".if a == b" gets here when the "a" is unquoted and doesn't
786 1.215 rillig * start with a '$'. This surprises people.
787 1.215 rillig * If what follows the function argument is a '=' or '!' then the
788 1.215 rillig * syntax would be invalid if we did "defined(a)" - so instead treat
789 1.215 rillig * as an expression.
790 1.215 rillig */
791 1.266 rillig /*
792 1.321 rillig * XXX: In edge cases, a variable expression may be evaluated twice,
793 1.321 rillig * see cond-token-plain.mk, keyword 'twice'.
794 1.266 rillig */
795 1.319 rillig arg = ParseWord(&cp, doEval);
796 1.319 rillig assert(arg[0] != '\0');
797 1.318 rillig
798 1.320 rillig if (*cp == '=' || *cp == '!' || *cp == '<' || *cp == '>')
799 1.215 rillig return CondParser_Comparison(par, doEval);
800 1.215 rillig par->p = cp;
801 1.215 rillig
802 1.215 rillig /*
803 1.215 rillig * Evaluate the argument using the default function.
804 1.215 rillig * This path always treats .if as .ifdef. To get here, the character
805 1.215 rillig * after .if must have been taken literally, so the argument cannot
806 1.215 rillig * be empty - even if it contained a variable expansion.
807 1.215 rillig */
808 1.317 rillig t = ToToken(doEval && EvalBare(par, arg));
809 1.215 rillig free(arg);
810 1.44 dsl return t;
811 1.44 dsl }
812 1.44 dsl
813 1.121 rillig /* Return the next token or comparison result from the parser. */
814 1.44 dsl static Token
815 1.260 rillig CondParser_Token(CondParser *par, bool doEval)
816 1.1 cgd {
817 1.215 rillig Token t;
818 1.215 rillig
819 1.215 rillig t = par->curr;
820 1.215 rillig if (t != TOK_NONE) {
821 1.215 rillig par->curr = TOK_NONE;
822 1.215 rillig return t;
823 1.215 rillig }
824 1.215 rillig
825 1.215 rillig cpp_skip_hspace(&par->p);
826 1.215 rillig
827 1.215 rillig switch (par->p[0]) {
828 1.215 rillig
829 1.215 rillig case '(':
830 1.215 rillig par->p++;
831 1.215 rillig return TOK_LPAREN;
832 1.215 rillig
833 1.215 rillig case ')':
834 1.215 rillig par->p++;
835 1.215 rillig return TOK_RPAREN;
836 1.215 rillig
837 1.215 rillig case '|':
838 1.215 rillig par->p++;
839 1.215 rillig if (par->p[0] == '|')
840 1.215 rillig par->p++;
841 1.231 rillig else if (opts.strict) {
842 1.215 rillig Parse_Error(PARSE_FATAL, "Unknown operator '|'");
843 1.260 rillig par->printedError = true;
844 1.215 rillig return TOK_ERROR;
845 1.215 rillig }
846 1.215 rillig return TOK_OR;
847 1.215 rillig
848 1.215 rillig case '&':
849 1.215 rillig par->p++;
850 1.215 rillig if (par->p[0] == '&')
851 1.215 rillig par->p++;
852 1.231 rillig else if (opts.strict) {
853 1.215 rillig Parse_Error(PARSE_FATAL, "Unknown operator '&'");
854 1.260 rillig par->printedError = true;
855 1.215 rillig return TOK_ERROR;
856 1.215 rillig }
857 1.215 rillig return TOK_AND;
858 1.47 dsl
859 1.215 rillig case '!':
860 1.215 rillig par->p++;
861 1.215 rillig return TOK_NOT;
862 1.47 dsl
863 1.215 rillig case '#': /* XXX: see unit-tests/cond-token-plain.mk */
864 1.215 rillig case '\n': /* XXX: why should this end the condition? */
865 1.215 rillig /* Probably obsolete now, from 1993-03-21. */
866 1.215 rillig case '\0':
867 1.215 rillig return TOK_EOF;
868 1.47 dsl
869 1.215 rillig case '"':
870 1.215 rillig case '$':
871 1.215 rillig return CondParser_Comparison(par, doEval);
872 1.47 dsl
873 1.215 rillig default:
874 1.290 rillig if (CondParser_FuncCallEmpty(par, doEval, &t))
875 1.290 rillig return t;
876 1.264 rillig if (CondParser_FuncCall(par, doEval, &t))
877 1.264 rillig return t;
878 1.266 rillig return CondParser_ComparisonOrLeaf(par, doEval);
879 1.215 rillig }
880 1.1 cgd }
881 1.47 dsl
882 1.289 rillig /* Skip the next token if it equals t. */
883 1.289 rillig static bool
884 1.289 rillig CondParser_Skip(CondParser *par, Token t)
885 1.289 rillig {
886 1.289 rillig Token actual;
887 1.289 rillig
888 1.289 rillig actual = CondParser_Token(par, false);
889 1.289 rillig if (actual == t)
890 1.289 rillig return true;
891 1.289 rillig
892 1.289 rillig assert(par->curr == TOK_NONE);
893 1.289 rillig assert(actual != TOK_NONE);
894 1.289 rillig par->curr = actual;
895 1.289 rillig return false;
896 1.289 rillig }
897 1.289 rillig
898 1.233 rillig /*
899 1.239 rillig * Term -> '(' Or ')'
900 1.239 rillig * Term -> '!' Term
901 1.239 rillig * Term -> Leaf Operator Leaf
902 1.239 rillig * Term -> Leaf
903 1.1 cgd */
904 1.241 rillig static CondResult
905 1.260 rillig CondParser_Term(CondParser *par, bool doEval)
906 1.1 cgd {
907 1.241 rillig CondResult res;
908 1.215 rillig Token t;
909 1.1 cgd
910 1.215 rillig t = CondParser_Token(par, doEval);
911 1.241 rillig if (t == TOK_TRUE)
912 1.241 rillig return CR_TRUE;
913 1.241 rillig if (t == TOK_FALSE)
914 1.241 rillig return CR_FALSE;
915 1.1 cgd
916 1.237 rillig if (t == TOK_LPAREN) {
917 1.241 rillig res = CondParser_Or(par, doEval);
918 1.241 rillig if (res == CR_ERROR)
919 1.241 rillig return CR_ERROR;
920 1.239 rillig if (CondParser_Token(par, doEval) != TOK_RPAREN)
921 1.241 rillig return CR_ERROR;
922 1.241 rillig return res;
923 1.239 rillig }
924 1.239 rillig
925 1.239 rillig if (t == TOK_NOT) {
926 1.241 rillig res = CondParser_Term(par, doEval);
927 1.241 rillig if (res == CR_TRUE)
928 1.241 rillig res = CR_FALSE;
929 1.241 rillig else if (res == CR_FALSE)
930 1.241 rillig res = CR_TRUE;
931 1.241 rillig return res;
932 1.239 rillig }
933 1.236 rillig
934 1.241 rillig return CR_ERROR;
935 1.1 cgd }
936 1.90 rillig
937 1.233 rillig /*
938 1.288 rillig * And -> Term ('&&' Term)*
939 1.1 cgd */
940 1.241 rillig static CondResult
941 1.260 rillig CondParser_And(CondParser *par, bool doEval)
942 1.1 cgd {
943 1.288 rillig CondResult res, rhs;
944 1.1 cgd
945 1.288 rillig res = CR_TRUE;
946 1.288 rillig do {
947 1.288 rillig if ((rhs = CondParser_Term(par, doEval)) == CR_ERROR)
948 1.241 rillig return CR_ERROR;
949 1.288 rillig if (rhs == CR_FALSE) {
950 1.288 rillig res = CR_FALSE;
951 1.288 rillig doEval = false;
952 1.288 rillig }
953 1.289 rillig } while (CondParser_Skip(par, TOK_AND));
954 1.239 rillig
955 1.239 rillig return res;
956 1.1 cgd }
957 1.90 rillig
958 1.233 rillig /*
959 1.285 rillig * Or -> And ('||' And)*
960 1.1 cgd */
961 1.241 rillig static CondResult
962 1.260 rillig CondParser_Or(CondParser *par, bool doEval)
963 1.1 cgd {
964 1.285 rillig CondResult res, rhs;
965 1.1 cgd
966 1.285 rillig res = CR_FALSE;
967 1.285 rillig do {
968 1.285 rillig if ((rhs = CondParser_And(par, doEval)) == CR_ERROR)
969 1.241 rillig return CR_ERROR;
970 1.285 rillig if (rhs == CR_TRUE) {
971 1.285 rillig res = CR_TRUE;
972 1.285 rillig doEval = false;
973 1.285 rillig }
974 1.289 rillig } while (CondParser_Skip(par, TOK_OR));
975 1.239 rillig
976 1.239 rillig return res;
977 1.1 cgd }
978 1.10 christos
979 1.312 rillig static CondResult
980 1.310 rillig CondParser_Eval(CondParser *par)
981 1.89 rillig {
982 1.241 rillig CondResult res;
983 1.128 rillig
984 1.215 rillig DEBUG1(COND, "CondParser_Eval: %s\n", par->p);
985 1.128 rillig
986 1.260 rillig res = CondParser_Or(par, true);
987 1.313 rillig if (res != CR_ERROR && CondParser_Token(par, false) != TOK_EOF)
988 1.311 rillig return CR_ERROR;
989 1.89 rillig
990 1.310 rillig return res;
991 1.89 rillig }
992 1.89 rillig
993 1.233 rillig /*
994 1.233 rillig * Evaluate the condition, including any side effects from the variable
995 1.128 rillig * expressions in the condition. The condition consists of &&, ||, !,
996 1.128 rillig * function(arg), comparisons and parenthetical groupings thereof.
997 1.10 christos */
998 1.312 rillig static CondResult
999 1.310 rillig CondEvalExpression(const char *cond, bool plain,
1000 1.297 rillig bool (*evalBare)(const char *), bool negate,
1001 1.277 rillig bool eprint, bool leftUnquotedOK)
1002 1.10 christos {
1003 1.215 rillig CondParser par;
1004 1.312 rillig CondResult rval;
1005 1.10 christos
1006 1.215 rillig cpp_skip_hspace(&cond);
1007 1.10 christos
1008 1.243 rillig par.plain = plain;
1009 1.243 rillig par.evalBare = evalBare;
1010 1.243 rillig par.negateEvalBare = negate;
1011 1.277 rillig par.leftUnquotedOK = leftUnquotedOK;
1012 1.215 rillig par.p = cond;
1013 1.215 rillig par.curr = TOK_NONE;
1014 1.260 rillig par.printedError = false;
1015 1.10 christos
1016 1.310 rillig rval = CondParser_Eval(&par);
1017 1.56 dsl
1018 1.311 rillig if (rval == CR_ERROR && eprint && !par.printedError)
1019 1.215 rillig Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", cond);
1020 1.56 dsl
1021 1.215 rillig return rval;
1022 1.56 dsl }
1023 1.56 dsl
1024 1.233 rillig /*
1025 1.233 rillig * Evaluate a condition in a :? modifier, such as
1026 1.233 rillig * ${"${VAR}" == value:?yes:no}.
1027 1.233 rillig */
1028 1.312 rillig CondResult
1029 1.310 rillig Cond_EvalCondition(const char *cond)
1030 1.142 rillig {
1031 1.310 rillig return CondEvalExpression(cond, true,
1032 1.277 rillig FuncDefined, false, false, true);
1033 1.142 rillig }
1034 1.90 rillig
1035 1.260 rillig static bool
1036 1.224 rillig IsEndif(const char *p)
1037 1.224 rillig {
1038 1.224 rillig return p[0] == 'e' && p[1] == 'n' && p[2] == 'd' &&
1039 1.224 rillig p[3] == 'i' && p[4] == 'f' && !ch_isalpha(p[5]);
1040 1.224 rillig }
1041 1.224 rillig
1042 1.260 rillig static bool
1043 1.260 rillig DetermineKindOfConditional(const char **pp, bool *out_plain,
1044 1.297 rillig bool (**out_evalBare)(const char *),
1045 1.260 rillig bool *out_negate)
1046 1.244 rillig {
1047 1.314 rillig const char *p = *pp + 2;
1048 1.244 rillig
1049 1.260 rillig *out_plain = false;
1050 1.244 rillig *out_evalBare = FuncDefined;
1051 1.314 rillig *out_negate = skip_string(&p, "n");
1052 1.314 rillig
1053 1.314 rillig if (skip_string(&p, "def")) { /* .ifdef and .ifndef */
1054 1.314 rillig } else if (skip_string(&p, "make")) /* .ifmake and .ifnmake */
1055 1.244 rillig *out_evalBare = FuncMake;
1056 1.314 rillig else if (!*out_negate) /* plain .if */
1057 1.260 rillig *out_plain = true;
1058 1.314 rillig else
1059 1.314 rillig goto unknown_directive;
1060 1.314 rillig if (ch_isalpha(*p))
1061 1.314 rillig goto unknown_directive;
1062 1.244 rillig
1063 1.244 rillig *pp = p;
1064 1.260 rillig return true;
1065 1.314 rillig
1066 1.314 rillig unknown_directive:
1067 1.314 rillig /*
1068 1.314 rillig * TODO: Add error message about unknown directive, since there is no
1069 1.314 rillig * other known directive that starts with 'el' or 'if'.
1070 1.314 rillig *
1071 1.314 rillig * Example: .elifx 123
1072 1.314 rillig */
1073 1.314 rillig return false;
1074 1.244 rillig }
1075 1.244 rillig
1076 1.233 rillig /*
1077 1.233 rillig * Evaluate the conditional directive in the line, which is one of:
1078 1.207 rillig *
1079 1.206 rillig * .if <cond>
1080 1.206 rillig * .ifmake <cond>
1081 1.206 rillig * .ifnmake <cond>
1082 1.206 rillig * .ifdef <cond>
1083 1.206 rillig * .ifndef <cond>
1084 1.206 rillig * .elif <cond>
1085 1.206 rillig * .elifmake <cond>
1086 1.206 rillig * .elifnmake <cond>
1087 1.206 rillig * .elifdef <cond>
1088 1.206 rillig * .elifndef <cond>
1089 1.206 rillig * .else
1090 1.206 rillig * .endif
1091 1.207 rillig *
1092 1.207 rillig * In these directives, <cond> consists of &&, ||, !, function(arg),
1093 1.207 rillig * comparisons, expressions, bare words, numbers and strings, and
1094 1.207 rillig * parenthetical groupings thereof.
1095 1.1 cgd *
1096 1.108 rillig * Results:
1097 1.311 rillig * CR_TRUE to continue parsing the lines that follow the
1098 1.260 rillig * conditional (when <cond> evaluates to true)
1099 1.311 rillig * CR_FALSE to skip the lines after the conditional
1100 1.260 rillig * (when <cond> evaluates to false, or when a previous
1101 1.108 rillig * branch has already been taken)
1102 1.311 rillig * CR_ERROR if the conditional was not valid, either because of
1103 1.108 rillig * a syntax error or because some variable was undefined
1104 1.108 rillig * or because the condition could not be evaluated
1105 1.1 cgd */
1106 1.312 rillig CondResult
1107 1.222 rillig Cond_EvalLine(const char *line)
1108 1.1 cgd {
1109 1.215 rillig typedef enum IfState {
1110 1.215 rillig
1111 1.260 rillig /* None of the previous <cond> evaluated to true. */
1112 1.215 rillig IFS_INITIAL = 0,
1113 1.215 rillig
1114 1.306 rillig /*
1115 1.306 rillig * The previous <cond> evaluated to true. The lines following
1116 1.306 rillig * this condition are interpreted.
1117 1.306 rillig */
1118 1.215 rillig IFS_ACTIVE = 1 << 0,
1119 1.215 rillig
1120 1.215 rillig /* The previous directive was an '.else'. */
1121 1.215 rillig IFS_SEEN_ELSE = 1 << 1,
1122 1.215 rillig
1123 1.260 rillig /* One of the previous <cond> evaluated to true. */
1124 1.215 rillig IFS_WAS_ACTIVE = 1 << 2
1125 1.207 rillig
1126 1.215 rillig } IfState;
1127 1.213 rillig
1128 1.215 rillig static enum IfState *cond_states = NULL;
1129 1.215 rillig static unsigned int cond_states_cap = 128;
1130 1.215 rillig
1131 1.260 rillig bool plain;
1132 1.297 rillig bool (*evalBare)(const char *);
1133 1.260 rillig bool negate;
1134 1.260 rillig bool isElif;
1135 1.310 rillig CondResult res;
1136 1.215 rillig IfState state;
1137 1.215 rillig const char *p = line;
1138 1.215 rillig
1139 1.215 rillig if (cond_states == NULL) {
1140 1.215 rillig cond_states = bmake_malloc(
1141 1.215 rillig cond_states_cap * sizeof *cond_states);
1142 1.215 rillig cond_states[0] = IFS_ACTIVE;
1143 1.215 rillig }
1144 1.215 rillig
1145 1.215 rillig p++; /* skip the leading '.' */
1146 1.215 rillig cpp_skip_hspace(&p);
1147 1.215 rillig
1148 1.224 rillig if (IsEndif(p)) { /* It is an '.endif'. */
1149 1.225 rillig if (p[5] != '\0') {
1150 1.225 rillig Parse_Error(PARSE_FATAL,
1151 1.282 rillig "The .endif directive does not take arguments");
1152 1.225 rillig }
1153 1.224 rillig
1154 1.224 rillig if (cond_depth == cond_min_depth) {
1155 1.224 rillig Parse_Error(PARSE_FATAL, "if-less endif");
1156 1.311 rillig return CR_TRUE;
1157 1.224 rillig }
1158 1.224 rillig
1159 1.224 rillig /* Return state for previous conditional */
1160 1.224 rillig cond_depth--;
1161 1.224 rillig return cond_states[cond_depth] & IFS_ACTIVE
1162 1.311 rillig ? CR_TRUE : CR_FALSE;
1163 1.224 rillig }
1164 1.224 rillig
1165 1.215 rillig /* Parse the name of the directive, such as 'if', 'elif', 'endif'. */
1166 1.215 rillig if (p[0] == 'e') {
1167 1.215 rillig if (p[1] != 'l') {
1168 1.224 rillig /*
1169 1.224 rillig * Unknown directive. It might still be a
1170 1.281 rillig * transformation rule like '.err.txt',
1171 1.224 rillig * therefore no error message here.
1172 1.224 rillig */
1173 1.311 rillig return CR_ERROR;
1174 1.215 rillig }
1175 1.211 rillig
1176 1.215 rillig /* Quite likely this is 'else' or 'elif' */
1177 1.215 rillig p += 2;
1178 1.314 rillig if (strncmp(p, "se", 2) == 0 && !ch_isalpha(p[2])) {
1179 1.226 rillig if (p[2] != '\0')
1180 1.215 rillig Parse_Error(PARSE_FATAL,
1181 1.282 rillig "The .else directive "
1182 1.282 rillig "does not take arguments");
1183 1.215 rillig
1184 1.215 rillig if (cond_depth == cond_min_depth) {
1185 1.215 rillig Parse_Error(PARSE_FATAL, "if-less else");
1186 1.311 rillig return CR_TRUE;
1187 1.215 rillig }
1188 1.215 rillig
1189 1.215 rillig state = cond_states[cond_depth];
1190 1.215 rillig if (state == IFS_INITIAL) {
1191 1.215 rillig state = IFS_ACTIVE | IFS_SEEN_ELSE;
1192 1.215 rillig } else {
1193 1.215 rillig if (state & IFS_SEEN_ELSE)
1194 1.215 rillig Parse_Error(PARSE_WARNING,
1195 1.305 rillig "extra else");
1196 1.215 rillig state = IFS_WAS_ACTIVE | IFS_SEEN_ELSE;
1197 1.215 rillig }
1198 1.215 rillig cond_states[cond_depth] = state;
1199 1.211 rillig
1200 1.311 rillig return state & IFS_ACTIVE ? CR_TRUE : CR_FALSE;
1201 1.215 rillig }
1202 1.215 rillig /* Assume for now it is an elif */
1203 1.260 rillig isElif = true;
1204 1.215 rillig } else
1205 1.260 rillig isElif = false;
1206 1.211 rillig
1207 1.215 rillig if (p[0] != 'i' || p[1] != 'f') {
1208 1.215 rillig /*
1209 1.215 rillig * Unknown directive. It might still be a transformation rule
1210 1.215 rillig * like '.elisp.scm', therefore no error message here.
1211 1.215 rillig */
1212 1.311 rillig return CR_ERROR; /* Not an ifxxx or elifxxx line */
1213 1.36 dsl }
1214 1.36 dsl
1215 1.244 rillig if (!DetermineKindOfConditional(&p, &plain, &evalBare, &negate))
1216 1.311 rillig return CR_ERROR;
1217 1.206 rillig
1218 1.215 rillig if (isElif) {
1219 1.215 rillig if (cond_depth == cond_min_depth) {
1220 1.215 rillig Parse_Error(PARSE_FATAL, "if-less elif");
1221 1.311 rillig return CR_TRUE;
1222 1.215 rillig }
1223 1.215 rillig state = cond_states[cond_depth];
1224 1.215 rillig if (state & IFS_SEEN_ELSE) {
1225 1.215 rillig Parse_Error(PARSE_WARNING, "extra elif");
1226 1.215 rillig cond_states[cond_depth] =
1227 1.215 rillig IFS_WAS_ACTIVE | IFS_SEEN_ELSE;
1228 1.311 rillig return CR_FALSE;
1229 1.215 rillig }
1230 1.215 rillig if (state != IFS_INITIAL) {
1231 1.215 rillig cond_states[cond_depth] = IFS_WAS_ACTIVE;
1232 1.311 rillig return CR_FALSE;
1233 1.215 rillig }
1234 1.215 rillig } else {
1235 1.215 rillig /* Normal .if */
1236 1.215 rillig if (cond_depth + 1 >= cond_states_cap) {
1237 1.215 rillig /*
1238 1.215 rillig * This is rare, but not impossible.
1239 1.215 rillig * In meta mode, dirdeps.mk (only runs at level 0)
1240 1.215 rillig * can need more than the default.
1241 1.215 rillig */
1242 1.215 rillig cond_states_cap += 32;
1243 1.215 rillig cond_states = bmake_realloc(cond_states,
1244 1.305 rillig cond_states_cap * sizeof *cond_states);
1245 1.215 rillig }
1246 1.215 rillig state = cond_states[cond_depth];
1247 1.215 rillig cond_depth++;
1248 1.215 rillig if (!(state & IFS_ACTIVE)) {
1249 1.215 rillig /*
1250 1.215 rillig * If we aren't parsing the data,
1251 1.215 rillig * treat as always false.
1252 1.215 rillig */
1253 1.215 rillig cond_states[cond_depth] = IFS_WAS_ACTIVE;
1254 1.311 rillig return CR_FALSE;
1255 1.215 rillig }
1256 1.215 rillig }
1257 1.215 rillig
1258 1.215 rillig /* And evaluate the conditional expression */
1259 1.310 rillig res = CondEvalExpression(p, plain, evalBare, negate, true, false);
1260 1.311 rillig if (res == CR_ERROR) {
1261 1.324 rillig /* Syntax error, error message already output. */
1262 1.324 rillig /* Skip everything to the matching '.endif'. */
1263 1.324 rillig /* An extra '.else' is not detected in this case. */
1264 1.215 rillig cond_states[cond_depth] = IFS_WAS_ACTIVE;
1265 1.311 rillig return CR_FALSE;
1266 1.215 rillig }
1267 1.215 rillig
1268 1.313 rillig cond_states[cond_depth] = res == CR_TRUE ? IFS_ACTIVE : IFS_INITIAL;
1269 1.313 rillig return res;
1270 1.1 cgd }
1271 1.10 christos
1272 1.1 cgd void
1273 1.37 dsl Cond_restore_depth(unsigned int saved_depth)
1274 1.1 cgd {
1275 1.215 rillig unsigned int open_conds = cond_depth - cond_min_depth;
1276 1.37 dsl
1277 1.215 rillig if (open_conds != 0 || saved_depth > cond_depth) {
1278 1.215 rillig Parse_Error(PARSE_FATAL, "%u open conditional%s",
1279 1.305 rillig open_conds, open_conds == 1 ? "" : "s");
1280 1.215 rillig cond_depth = cond_min_depth;
1281 1.215 rillig }
1282 1.37 dsl
1283 1.215 rillig cond_min_depth = saved_depth;
1284 1.37 dsl }
1285 1.37 dsl
1286 1.37 dsl unsigned int
1287 1.37 dsl Cond_save_depth(void)
1288 1.37 dsl {
1289 1.215 rillig unsigned int depth = cond_min_depth;
1290 1.37 dsl
1291 1.215 rillig cond_min_depth = cond_depth;
1292 1.215 rillig return depth;
1293 1.1 cgd }
1294