cond.c revision 1.329 1 1.329 rillig /* $NetBSD: cond.c,v 1.329 2022/02/09 21:09:24 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.329 rillig MAKE_RCSID("$NetBSD: cond.c,v 1.329 2022/02/09 21:09:24 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.329 rillig /* See if 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.326 rillig return Var_Exists(SCOPE_CMDLINE, var);
294 1.1 cgd }
295 1.90 rillig
296 1.328 rillig /* See if a target matching targetPattern is requested to be made. */
297 1.260 rillig static bool
298 1.328 rillig FuncMake(const char *targetPattern)
299 1.1 cgd {
300 1.215 rillig StringListNode *ln;
301 1.166 rillig
302 1.219 rillig for (ln = opts.create.first; ln != NULL; ln = ln->next)
303 1.328 rillig if (Str_Match(ln->datum, targetPattern))
304 1.260 rillig return true;
305 1.260 rillig return false;
306 1.1 cgd }
307 1.90 rillig
308 1.90 rillig /* See if the given file exists. */
309 1.260 rillig static bool
310 1.324 rillig FuncExists(const char *file)
311 1.1 cgd {
312 1.260 rillig bool result;
313 1.215 rillig char *path;
314 1.1 cgd
315 1.324 rillig path = Dir_FindFile(file, &dirSearchPath);
316 1.215 rillig DEBUG2(COND, "exists(%s) result is \"%s\"\n",
317 1.324 rillig file, path != NULL ? path : "");
318 1.215 rillig result = path != NULL;
319 1.215 rillig free(path);
320 1.215 rillig return result;
321 1.1 cgd }
322 1.90 rillig
323 1.90 rillig /* See if the given node exists and is an actual target. */
324 1.260 rillig static bool
325 1.324 rillig FuncTarget(const char *node)
326 1.1 cgd {
327 1.324 rillig GNode *gn = Targ_FindNode(node);
328 1.215 rillig return gn != NULL && GNode_IsTarget(gn);
329 1.1 cgd }
330 1.1 cgd
331 1.233 rillig /*
332 1.233 rillig * See if the given node exists and is an actual target with commands
333 1.233 rillig * associated with it.
334 1.233 rillig */
335 1.260 rillig static bool
336 1.324 rillig FuncCommands(const char *node)
337 1.12 christos {
338 1.324 rillig GNode *gn = Targ_FindNode(node);
339 1.324 rillig return gn != NULL && GNode_IsTarget(gn) &&
340 1.324 rillig !Lst_IsEmpty(&gn->commands);
341 1.12 christos }
342 1.90 rillig
343 1.189 rillig /*
344 1.324 rillig * Convert the string into a floating-point number. Accepted formats are
345 1.324 rillig * base-10 integer, base-16 integer and finite floating point numbers.
346 1.1 cgd */
347 1.260 rillig static bool
348 1.189 rillig TryParseNumber(const char *str, double *out_value)
349 1.1 cgd {
350 1.215 rillig char *end;
351 1.215 rillig unsigned long ul_val;
352 1.215 rillig double dbl_val;
353 1.215 rillig
354 1.215 rillig if (str[0] == '\0') { /* XXX: why is an empty string a number? */
355 1.215 rillig *out_value = 0.0;
356 1.260 rillig return true;
357 1.215 rillig }
358 1.189 rillig
359 1.270 rillig errno = 0;
360 1.215 rillig ul_val = strtoul(str, &end, str[1] == 'x' ? 16 : 10);
361 1.215 rillig if (*end == '\0' && errno != ERANGE) {
362 1.215 rillig *out_value = str[0] == '-' ? -(double)-ul_val : (double)ul_val;
363 1.260 rillig return true;
364 1.215 rillig }
365 1.46 dsl
366 1.215 rillig if (*end != '\0' && *end != '.' && *end != 'e' && *end != 'E')
367 1.260 rillig return false; /* skip the expensive strtod call */
368 1.215 rillig dbl_val = strtod(str, &end);
369 1.215 rillig if (*end != '\0')
370 1.260 rillig return false;
371 1.189 rillig
372 1.215 rillig *out_value = dbl_val;
373 1.260 rillig return true;
374 1.1 cgd }
375 1.46 dsl
376 1.260 rillig static bool
377 1.140 rillig is_separator(char ch)
378 1.140 rillig {
379 1.267 rillig return ch == '\0' || ch_isspace(ch) || ch == '!' || ch == '=' ||
380 1.267 rillig ch == '>' || ch == '<' || ch == ')' /* but not '(' */;
381 1.140 rillig }
382 1.140 rillig
383 1.242 rillig /*
384 1.248 rillig * In a quoted or unquoted string literal or a number, parse a variable
385 1.248 rillig * expression.
386 1.248 rillig *
387 1.248 rillig * Example: .if x${CENTER}y == "${PREFIX}${SUFFIX}" || 0x${HEX}
388 1.248 rillig */
389 1.260 rillig static bool
390 1.248 rillig CondParser_StringExpr(CondParser *par, const char *start,
391 1.274 rillig bool doEval, bool quoted,
392 1.274 rillig Buffer *buf, FStr *inout_str)
393 1.248 rillig {
394 1.261 rillig VarEvalMode emode;
395 1.308 rillig const char *p;
396 1.260 rillig bool atStart;
397 1.248 rillig VarParseResult parseResult;
398 1.248 rillig
399 1.275 rillig emode = doEval && quoted ? VARE_WANTRES
400 1.275 rillig : doEval ? VARE_UNDEFERR
401 1.258 rillig : VARE_PARSE_ONLY;
402 1.248 rillig
403 1.308 rillig p = par->p;
404 1.308 rillig atStart = p == start;
405 1.308 rillig parseResult = Var_Parse(&p, SCOPE_CMDLINE, emode, inout_str);
406 1.248 rillig /* TODO: handle errors */
407 1.248 rillig if (inout_str->str == var_Error) {
408 1.248 rillig if (parseResult == VPR_ERR) {
409 1.248 rillig /*
410 1.249 rillig * FIXME: Even if an error occurs, there is no
411 1.249 rillig * guarantee that it is reported.
412 1.248 rillig *
413 1.248 rillig * See cond-token-plain.mk $$$$$$$$.
414 1.248 rillig */
415 1.260 rillig par->printedError = true;
416 1.248 rillig }
417 1.248 rillig /*
418 1.249 rillig * XXX: Can there be any situation in which a returned
419 1.257 rillig * var_Error needs to be freed?
420 1.248 rillig */
421 1.248 rillig FStr_Done(inout_str);
422 1.248 rillig /*
423 1.249 rillig * Even if !doEval, we still report syntax errors, which is
424 1.249 rillig * what getting var_Error back with !doEval means.
425 1.248 rillig */
426 1.248 rillig *inout_str = FStr_InitRefer(NULL);
427 1.260 rillig return false;
428 1.248 rillig }
429 1.308 rillig par->p = p;
430 1.248 rillig
431 1.248 rillig /*
432 1.249 rillig * If the '$' started the string literal (which means no quotes), and
433 1.249 rillig * the variable expression is followed by a space, looks like a
434 1.249 rillig * comparison operator or is the end of the expression, we are done.
435 1.248 rillig */
436 1.248 rillig if (atStart && is_separator(par->p[0]))
437 1.260 rillig return false;
438 1.248 rillig
439 1.248 rillig Buf_AddStr(buf, inout_str->str);
440 1.248 rillig FStr_Done(inout_str);
441 1.306 rillig *inout_str = FStr_InitRefer(NULL); /* not finished yet */
442 1.260 rillig return true;
443 1.248 rillig }
444 1.248 rillig
445 1.248 rillig /*
446 1.307 rillig * Parse a string from a variable expression or an optionally quoted string,
447 1.307 rillig * on the left-hand and right-hand sides of comparisons.
448 1.23 sjg *
449 1.23 sjg * Results:
450 1.307 rillig * Returns the string without any enclosing quotes, or NULL on error.
451 1.266 rillig * Sets out_quoted if the leaf was a quoted string literal.
452 1.23 sjg */
453 1.227 rillig static void
454 1.277 rillig CondParser_Leaf(CondParser *par, bool doEval, bool unquotedOK,
455 1.260 rillig FStr *out_str, bool *out_quoted)
456 1.23 sjg {
457 1.215 rillig Buffer buf;
458 1.228 rillig FStr str;
459 1.260 rillig bool quoted;
460 1.215 rillig const char *start;
461 1.215 rillig
462 1.215 rillig Buf_Init(&buf);
463 1.228 rillig str = FStr_InitRefer(NULL);
464 1.215 rillig *out_quoted = quoted = par->p[0] == '"';
465 1.215 rillig start = par->p;
466 1.215 rillig if (quoted)
467 1.122 rillig par->p++;
468 1.227 rillig
469 1.228 rillig while (par->p[0] != '\0' && str.str == NULL) {
470 1.215 rillig switch (par->p[0]) {
471 1.215 rillig case '\\':
472 1.215 rillig par->p++;
473 1.215 rillig if (par->p[0] != '\0') {
474 1.215 rillig Buf_AddByte(&buf, par->p[0]);
475 1.215 rillig par->p++;
476 1.215 rillig }
477 1.215 rillig continue;
478 1.215 rillig case '"':
479 1.215 rillig par->p++;
480 1.246 rillig if (quoted)
481 1.327 rillig goto return_buf; /* skip the closing quote */
482 1.246 rillig Buf_AddByte(&buf, '"');
483 1.215 rillig continue;
484 1.215 rillig case ')': /* see is_separator */
485 1.215 rillig case '!':
486 1.215 rillig case '=':
487 1.215 rillig case '>':
488 1.215 rillig case '<':
489 1.215 rillig case ' ':
490 1.215 rillig case '\t':
491 1.215 rillig if (!quoted)
492 1.327 rillig goto return_buf;
493 1.215 rillig Buf_AddByte(&buf, par->p[0]);
494 1.215 rillig par->p++;
495 1.215 rillig continue;
496 1.215 rillig case '$':
497 1.248 rillig if (!CondParser_StringExpr(par,
498 1.248 rillig start, doEval, quoted, &buf, &str))
499 1.327 rillig goto return_str;
500 1.215 rillig continue;
501 1.215 rillig default:
502 1.277 rillig if (!unquotedOK && !quoted && *start != '$' &&
503 1.215 rillig !ch_isdigit(*start)) {
504 1.215 rillig /*
505 1.215 rillig * The left-hand side must be quoted,
506 1.277 rillig * a variable expression or a number.
507 1.215 rillig */
508 1.228 rillig str = FStr_InitRefer(NULL);
509 1.327 rillig goto return_str;
510 1.215 rillig }
511 1.215 rillig Buf_AddByte(&buf, par->p[0]);
512 1.215 rillig par->p++;
513 1.215 rillig continue;
514 1.30 christos }
515 1.23 sjg }
516 1.327 rillig return_buf:
517 1.254 rillig str = FStr_InitOwn(buf.data);
518 1.303 rillig buf.data = NULL;
519 1.327 rillig return_str:
520 1.303 rillig Buf_Done(&buf);
521 1.227 rillig *out_str = str;
522 1.23 sjg }
523 1.89 rillig
524 1.233 rillig /*
525 1.233 rillig * Evaluate a "comparison without operator", such as in ".if ${VAR}" or
526 1.233 rillig * ".if 0".
527 1.233 rillig */
528 1.260 rillig static bool
529 1.260 rillig EvalNotEmpty(CondParser *par, const char *value, bool quoted)
530 1.131 rillig {
531 1.215 rillig double num;
532 1.131 rillig
533 1.215 rillig /* For .ifxxx "...", check for non-empty string. */
534 1.215 rillig if (quoted)
535 1.215 rillig return value[0] != '\0';
536 1.215 rillig
537 1.215 rillig /* For .ifxxx <number>, compare against zero */
538 1.215 rillig if (TryParseNumber(value, &num))
539 1.215 rillig return num != 0.0;
540 1.215 rillig
541 1.306 rillig /*
542 1.306 rillig * For .if ${...}, check for non-empty string. This is different
543 1.306 rillig * from the evaluation function from that .if variant, which would
544 1.306 rillig * test whether a variable of the given name were defined.
545 1.306 rillig */
546 1.295 rillig /*
547 1.295 rillig * XXX: Whitespace should count as empty, just as in
548 1.295 rillig * CondParser_FuncCallEmpty.
549 1.295 rillig */
550 1.243 rillig if (par->plain)
551 1.215 rillig return value[0] != '\0';
552 1.131 rillig
553 1.325 rillig return par->evalBare(value) != par->negateEvalBare;
554 1.131 rillig }
555 1.131 rillig
556 1.133 rillig /* Evaluate a numerical comparison, such as in ".if ${VAR} >= 9". */
557 1.260 rillig static bool
558 1.251 rillig EvalCompareNum(double lhs, ComparisonOp op, double rhs)
559 1.130 rillig {
560 1.251 rillig DEBUG3(COND, "lhs = %f, rhs = %f, op = %.2s\n", lhs, rhs, opname[op]);
561 1.130 rillig
562 1.251 rillig switch (op) {
563 1.251 rillig case LT:
564 1.251 rillig return lhs < rhs;
565 1.251 rillig case LE:
566 1.251 rillig return lhs <= rhs;
567 1.251 rillig case GT:
568 1.251 rillig return lhs > rhs;
569 1.251 rillig case GE:
570 1.251 rillig return lhs >= rhs;
571 1.251 rillig case NE:
572 1.251 rillig return lhs != rhs;
573 1.251 rillig default:
574 1.251 rillig return lhs == rhs;
575 1.215 rillig }
576 1.130 rillig }
577 1.130 rillig
578 1.133 rillig static Token
579 1.252 rillig EvalCompareStr(CondParser *par, const char *lhs,
580 1.252 rillig ComparisonOp op, const char *rhs)
581 1.133 rillig {
582 1.251 rillig if (op != EQ && op != NE) {
583 1.252 rillig Parse_Error(PARSE_FATAL,
584 1.251 rillig "String comparison operator must be either == or !=");
585 1.260 rillig par->printedError = true;
586 1.215 rillig return TOK_ERROR;
587 1.215 rillig }
588 1.133 rillig
589 1.251 rillig DEBUG3(COND, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n",
590 1.251 rillig lhs, rhs, opname[op]);
591 1.251 rillig return ToToken((op == EQ) == (strcmp(lhs, rhs) == 0));
592 1.133 rillig }
593 1.133 rillig
594 1.133 rillig /* Evaluate a comparison, such as "${VAR} == 12345". */
595 1.133 rillig static Token
596 1.260 rillig EvalCompare(CondParser *par, const char *lhs, bool lhsQuoted,
597 1.260 rillig ComparisonOp op, const char *rhs, bool rhsQuoted)
598 1.133 rillig {
599 1.215 rillig double left, right;
600 1.133 rillig
601 1.215 rillig if (!rhsQuoted && !lhsQuoted)
602 1.215 rillig if (TryParseNumber(lhs, &left) && TryParseNumber(rhs, &right))
603 1.251 rillig return ToToken(EvalCompareNum(left, op, right));
604 1.133 rillig
605 1.252 rillig return EvalCompareStr(par, lhs, op, rhs);
606 1.133 rillig }
607 1.133 rillig
608 1.260 rillig static bool
609 1.251 rillig CondParser_ComparisonOp(CondParser *par, ComparisonOp *out_op)
610 1.251 rillig {
611 1.251 rillig const char *p = par->p;
612 1.251 rillig
613 1.304 rillig if (p[0] == '<' && p[1] == '=')
614 1.304 rillig return par->p += 2, *out_op = LE, true;
615 1.304 rillig if (p[0] == '<')
616 1.304 rillig return par->p += 1, *out_op = LT, true;
617 1.304 rillig if (p[0] == '>' && p[1] == '=')
618 1.304 rillig return par->p += 2, *out_op = GE, true;
619 1.304 rillig if (p[0] == '>')
620 1.304 rillig return par->p += 1, *out_op = GT, true;
621 1.304 rillig if (p[0] == '=' && p[1] == '=')
622 1.304 rillig return par->p += 2, *out_op = EQ, true;
623 1.304 rillig if (p[0] == '!' && p[1] == '=')
624 1.304 rillig return par->p += 2, *out_op = NE, true;
625 1.260 rillig return false;
626 1.251 rillig }
627 1.251 rillig
628 1.233 rillig /*
629 1.233 rillig * Parse a comparison condition such as:
630 1.129 rillig *
631 1.129 rillig * 0
632 1.129 rillig * ${VAR:Mpattern}
633 1.129 rillig * ${VAR} == value
634 1.129 rillig * ${VAR:U0} < 12345
635 1.129 rillig */
636 1.1 cgd static Token
637 1.260 rillig CondParser_Comparison(CondParser *par, bool doEval)
638 1.44 dsl {
639 1.215 rillig Token t = TOK_ERROR;
640 1.228 rillig FStr lhs, rhs;
641 1.251 rillig ComparisonOp op;
642 1.260 rillig bool lhsQuoted, rhsQuoted;
643 1.215 rillig
644 1.277 rillig CondParser_Leaf(par, doEval, par->leftUnquotedOK, &lhs, &lhsQuoted);
645 1.228 rillig if (lhs.str == NULL)
646 1.215 rillig goto done_lhs;
647 1.215 rillig
648 1.215 rillig CondParser_SkipWhitespace(par);
649 1.215 rillig
650 1.251 rillig if (!CondParser_ComparisonOp(par, &op)) {
651 1.215 rillig /* Unknown operator, compare against an empty string or 0. */
652 1.228 rillig t = ToToken(doEval && EvalNotEmpty(par, lhs.str, lhsQuoted));
653 1.215 rillig goto done_lhs;
654 1.215 rillig }
655 1.215 rillig
656 1.215 rillig CondParser_SkipWhitespace(par);
657 1.215 rillig
658 1.215 rillig if (par->p[0] == '\0') {
659 1.252 rillig Parse_Error(PARSE_FATAL,
660 1.269 rillig "Missing right-hand side of operator '%s'", opname[op]);
661 1.260 rillig par->printedError = true;
662 1.215 rillig goto done_lhs;
663 1.215 rillig }
664 1.215 rillig
665 1.277 rillig CondParser_Leaf(par, doEval, true, &rhs, &rhsQuoted);
666 1.228 rillig if (rhs.str == NULL)
667 1.215 rillig goto done_rhs;
668 1.215 rillig
669 1.215 rillig if (!doEval) {
670 1.215 rillig t = TOK_FALSE;
671 1.215 rillig goto done_rhs;
672 1.215 rillig }
673 1.79 sjg
674 1.252 rillig t = EvalCompare(par, lhs.str, lhsQuoted, op, rhs.str, rhsQuoted);
675 1.58 dsl
676 1.185 rillig done_rhs:
677 1.228 rillig FStr_Done(&rhs);
678 1.185 rillig done_lhs:
679 1.228 rillig FStr_Done(&lhs);
680 1.215 rillig return t;
681 1.44 dsl }
682 1.44 dsl
683 1.233 rillig /*
684 1.233 rillig * The argument to empty() is a variable name, optionally followed by
685 1.233 rillig * variable modifiers.
686 1.233 rillig */
687 1.295 rillig static bool
688 1.295 rillig CondParser_FuncCallEmpty(CondParser *par, bool doEval, Token *out_token)
689 1.47 dsl {
690 1.295 rillig const char *cp = par->p;
691 1.295 rillig Token tok;
692 1.229 rillig FStr val;
693 1.215 rillig
694 1.314 rillig if (!skip_string(&cp, "empty"))
695 1.295 rillig return false;
696 1.295 rillig
697 1.295 rillig cpp_skip_whitespace(&cp);
698 1.295 rillig if (*cp != '(')
699 1.295 rillig return false;
700 1.295 rillig
701 1.295 rillig cp--; /* Make cp[1] point to the '('. */
702 1.295 rillig (void)Var_Parse(&cp, SCOPE_CMDLINE,
703 1.258 rillig doEval ? VARE_WANTRES : VARE_PARSE_ONLY, &val);
704 1.215 rillig /* TODO: handle errors */
705 1.215 rillig
706 1.293 rillig if (val.str == var_Error)
707 1.293 rillig tok = TOK_ERROR;
708 1.293 rillig else {
709 1.293 rillig cpp_skip_whitespace(&val.str);
710 1.317 rillig tok = ToToken(doEval && val.str[0] == '\0');
711 1.215 rillig }
712 1.215 rillig
713 1.229 rillig FStr_Done(&val);
714 1.294 rillig *out_token = tok;
715 1.290 rillig par->p = cp;
716 1.290 rillig return true;
717 1.290 rillig }
718 1.290 rillig
719 1.263 rillig /* Parse a function call expression, such as 'defined(${file})'. */
720 1.260 rillig static bool
721 1.263 rillig CondParser_FuncCall(CondParser *par, bool doEval, Token *out_token)
722 1.44 dsl {
723 1.318 rillig char *arg;
724 1.314 rillig const char *p = par->p;
725 1.314 rillig bool (*fn)(const char *);
726 1.314 rillig const char *fn_name = p;
727 1.215 rillig
728 1.314 rillig if (skip_string(&p, "defined"))
729 1.314 rillig fn = FuncDefined;
730 1.314 rillig else if (skip_string(&p, "make"))
731 1.314 rillig fn = FuncMake;
732 1.314 rillig else if (skip_string(&p, "exists"))
733 1.314 rillig fn = FuncExists;
734 1.314 rillig else if (skip_string(&p, "target"))
735 1.314 rillig fn = FuncTarget;
736 1.314 rillig else if (skip_string(&p, "commands"))
737 1.314 rillig fn = FuncCommands;
738 1.314 rillig else
739 1.314 rillig return false;
740 1.272 rillig
741 1.314 rillig cpp_skip_whitespace(&p);
742 1.314 rillig if (*p != '(')
743 1.272 rillig return false;
744 1.215 rillig
745 1.319 rillig arg = ParseFuncArg(par, &p, doEval, fn_name);
746 1.319 rillig *out_token = ToToken(doEval &&
747 1.319 rillig arg != NULL && arg[0] != '\0' && fn(arg));
748 1.318 rillig free(arg);
749 1.200 rillig
750 1.314 rillig par->p = p;
751 1.272 rillig return true;
752 1.196 rillig }
753 1.196 rillig
754 1.233 rillig /*
755 1.302 rillig * Parse a comparison that neither starts with '"' nor '$', such as the
756 1.302 rillig * unusual 'bare == right' or '3 == ${VAR}', or a simple leaf without
757 1.266 rillig * operator, which is a number, a variable expression or a string literal.
758 1.302 rillig *
759 1.302 rillig * TODO: Can this be merged into CondParser_Comparison?
760 1.233 rillig */
761 1.196 rillig static Token
762 1.266 rillig CondParser_ComparisonOrLeaf(CondParser *par, bool doEval)
763 1.196 rillig {
764 1.215 rillig Token t;
765 1.323 rillig char *arg;
766 1.221 rillig const char *cp;
767 1.215 rillig
768 1.215 rillig /* Push anything numeric through the compare expression */
769 1.215 rillig cp = par->p;
770 1.215 rillig if (ch_isdigit(cp[0]) || cp[0] == '-' || cp[0] == '+')
771 1.215 rillig return CondParser_Comparison(par, doEval);
772 1.196 rillig
773 1.215 rillig /*
774 1.215 rillig * Most likely we have a naked token to apply the default function to.
775 1.215 rillig * However ".if a == b" gets here when the "a" is unquoted and doesn't
776 1.215 rillig * start with a '$'. This surprises people.
777 1.215 rillig * If what follows the function argument is a '=' or '!' then the
778 1.215 rillig * syntax would be invalid if we did "defined(a)" - so instead treat
779 1.215 rillig * as an expression.
780 1.215 rillig */
781 1.266 rillig /*
782 1.321 rillig * XXX: In edge cases, a variable expression may be evaluated twice,
783 1.321 rillig * see cond-token-plain.mk, keyword 'twice'.
784 1.266 rillig */
785 1.319 rillig arg = ParseWord(&cp, doEval);
786 1.319 rillig assert(arg[0] != '\0');
787 1.318 rillig
788 1.320 rillig if (*cp == '=' || *cp == '!' || *cp == '<' || *cp == '>')
789 1.215 rillig return CondParser_Comparison(par, doEval);
790 1.215 rillig par->p = cp;
791 1.215 rillig
792 1.215 rillig /*
793 1.215 rillig * Evaluate the argument using the default function.
794 1.215 rillig * This path always treats .if as .ifdef. To get here, the character
795 1.215 rillig * after .if must have been taken literally, so the argument cannot
796 1.215 rillig * be empty - even if it contained a variable expansion.
797 1.215 rillig */
798 1.325 rillig t = ToToken(doEval && par->evalBare(arg) != par->negateEvalBare);
799 1.215 rillig free(arg);
800 1.44 dsl return t;
801 1.44 dsl }
802 1.44 dsl
803 1.121 rillig /* Return the next token or comparison result from the parser. */
804 1.44 dsl static Token
805 1.260 rillig CondParser_Token(CondParser *par, bool doEval)
806 1.1 cgd {
807 1.215 rillig Token t;
808 1.215 rillig
809 1.215 rillig t = par->curr;
810 1.215 rillig if (t != TOK_NONE) {
811 1.215 rillig par->curr = TOK_NONE;
812 1.215 rillig return t;
813 1.215 rillig }
814 1.215 rillig
815 1.215 rillig cpp_skip_hspace(&par->p);
816 1.215 rillig
817 1.215 rillig switch (par->p[0]) {
818 1.215 rillig
819 1.215 rillig case '(':
820 1.215 rillig par->p++;
821 1.215 rillig return TOK_LPAREN;
822 1.215 rillig
823 1.215 rillig case ')':
824 1.215 rillig par->p++;
825 1.215 rillig return TOK_RPAREN;
826 1.215 rillig
827 1.215 rillig case '|':
828 1.215 rillig par->p++;
829 1.215 rillig if (par->p[0] == '|')
830 1.215 rillig par->p++;
831 1.231 rillig else if (opts.strict) {
832 1.215 rillig Parse_Error(PARSE_FATAL, "Unknown operator '|'");
833 1.260 rillig par->printedError = true;
834 1.215 rillig return TOK_ERROR;
835 1.215 rillig }
836 1.215 rillig return TOK_OR;
837 1.215 rillig
838 1.215 rillig case '&':
839 1.215 rillig par->p++;
840 1.215 rillig if (par->p[0] == '&')
841 1.215 rillig par->p++;
842 1.231 rillig else if (opts.strict) {
843 1.215 rillig Parse_Error(PARSE_FATAL, "Unknown operator '&'");
844 1.260 rillig par->printedError = true;
845 1.215 rillig return TOK_ERROR;
846 1.215 rillig }
847 1.215 rillig return TOK_AND;
848 1.47 dsl
849 1.215 rillig case '!':
850 1.215 rillig par->p++;
851 1.215 rillig return TOK_NOT;
852 1.47 dsl
853 1.215 rillig case '#': /* XXX: see unit-tests/cond-token-plain.mk */
854 1.215 rillig case '\n': /* XXX: why should this end the condition? */
855 1.215 rillig /* Probably obsolete now, from 1993-03-21. */
856 1.215 rillig case '\0':
857 1.215 rillig return TOK_EOF;
858 1.47 dsl
859 1.215 rillig case '"':
860 1.215 rillig case '$':
861 1.215 rillig return CondParser_Comparison(par, doEval);
862 1.47 dsl
863 1.215 rillig default:
864 1.290 rillig if (CondParser_FuncCallEmpty(par, doEval, &t))
865 1.290 rillig return t;
866 1.264 rillig if (CondParser_FuncCall(par, doEval, &t))
867 1.264 rillig return t;
868 1.266 rillig return CondParser_ComparisonOrLeaf(par, doEval);
869 1.215 rillig }
870 1.1 cgd }
871 1.47 dsl
872 1.289 rillig /* Skip the next token if it equals t. */
873 1.289 rillig static bool
874 1.289 rillig CondParser_Skip(CondParser *par, Token t)
875 1.289 rillig {
876 1.289 rillig Token actual;
877 1.289 rillig
878 1.289 rillig actual = CondParser_Token(par, false);
879 1.289 rillig if (actual == t)
880 1.289 rillig return true;
881 1.289 rillig
882 1.289 rillig assert(par->curr == TOK_NONE);
883 1.289 rillig assert(actual != TOK_NONE);
884 1.289 rillig par->curr = actual;
885 1.289 rillig return false;
886 1.289 rillig }
887 1.289 rillig
888 1.233 rillig /*
889 1.239 rillig * Term -> '(' Or ')'
890 1.239 rillig * Term -> '!' Term
891 1.239 rillig * Term -> Leaf Operator Leaf
892 1.239 rillig * Term -> Leaf
893 1.1 cgd */
894 1.241 rillig static CondResult
895 1.260 rillig CondParser_Term(CondParser *par, bool doEval)
896 1.1 cgd {
897 1.241 rillig CondResult res;
898 1.215 rillig Token t;
899 1.1 cgd
900 1.215 rillig t = CondParser_Token(par, doEval);
901 1.241 rillig if (t == TOK_TRUE)
902 1.241 rillig return CR_TRUE;
903 1.241 rillig if (t == TOK_FALSE)
904 1.241 rillig return CR_FALSE;
905 1.1 cgd
906 1.237 rillig if (t == TOK_LPAREN) {
907 1.241 rillig res = CondParser_Or(par, doEval);
908 1.241 rillig if (res == CR_ERROR)
909 1.241 rillig return CR_ERROR;
910 1.239 rillig if (CondParser_Token(par, doEval) != TOK_RPAREN)
911 1.241 rillig return CR_ERROR;
912 1.241 rillig return res;
913 1.239 rillig }
914 1.239 rillig
915 1.239 rillig if (t == TOK_NOT) {
916 1.241 rillig res = CondParser_Term(par, doEval);
917 1.241 rillig if (res == CR_TRUE)
918 1.241 rillig res = CR_FALSE;
919 1.241 rillig else if (res == CR_FALSE)
920 1.241 rillig res = CR_TRUE;
921 1.241 rillig return res;
922 1.239 rillig }
923 1.236 rillig
924 1.241 rillig return CR_ERROR;
925 1.1 cgd }
926 1.90 rillig
927 1.233 rillig /*
928 1.288 rillig * And -> Term ('&&' Term)*
929 1.1 cgd */
930 1.241 rillig static CondResult
931 1.260 rillig CondParser_And(CondParser *par, bool doEval)
932 1.1 cgd {
933 1.288 rillig CondResult res, rhs;
934 1.1 cgd
935 1.288 rillig res = CR_TRUE;
936 1.288 rillig do {
937 1.288 rillig if ((rhs = CondParser_Term(par, doEval)) == CR_ERROR)
938 1.241 rillig return CR_ERROR;
939 1.288 rillig if (rhs == CR_FALSE) {
940 1.288 rillig res = CR_FALSE;
941 1.288 rillig doEval = false;
942 1.288 rillig }
943 1.289 rillig } while (CondParser_Skip(par, TOK_AND));
944 1.239 rillig
945 1.239 rillig return res;
946 1.1 cgd }
947 1.90 rillig
948 1.233 rillig /*
949 1.285 rillig * Or -> And ('||' And)*
950 1.1 cgd */
951 1.241 rillig static CondResult
952 1.260 rillig CondParser_Or(CondParser *par, bool doEval)
953 1.1 cgd {
954 1.285 rillig CondResult res, rhs;
955 1.1 cgd
956 1.285 rillig res = CR_FALSE;
957 1.285 rillig do {
958 1.285 rillig if ((rhs = CondParser_And(par, doEval)) == CR_ERROR)
959 1.241 rillig return CR_ERROR;
960 1.285 rillig if (rhs == CR_TRUE) {
961 1.285 rillig res = CR_TRUE;
962 1.285 rillig doEval = false;
963 1.285 rillig }
964 1.289 rillig } while (CondParser_Skip(par, TOK_OR));
965 1.239 rillig
966 1.239 rillig return res;
967 1.1 cgd }
968 1.10 christos
969 1.312 rillig static CondResult
970 1.310 rillig CondParser_Eval(CondParser *par)
971 1.89 rillig {
972 1.241 rillig CondResult res;
973 1.128 rillig
974 1.215 rillig DEBUG1(COND, "CondParser_Eval: %s\n", par->p);
975 1.128 rillig
976 1.260 rillig res = CondParser_Or(par, true);
977 1.313 rillig if (res != CR_ERROR && CondParser_Token(par, false) != TOK_EOF)
978 1.311 rillig return CR_ERROR;
979 1.89 rillig
980 1.310 rillig return res;
981 1.89 rillig }
982 1.89 rillig
983 1.233 rillig /*
984 1.233 rillig * Evaluate the condition, including any side effects from the variable
985 1.128 rillig * expressions in the condition. The condition consists of &&, ||, !,
986 1.128 rillig * function(arg), comparisons and parenthetical groupings thereof.
987 1.10 christos */
988 1.312 rillig static CondResult
989 1.310 rillig CondEvalExpression(const char *cond, bool plain,
990 1.297 rillig bool (*evalBare)(const char *), bool negate,
991 1.277 rillig bool eprint, bool leftUnquotedOK)
992 1.10 christos {
993 1.215 rillig CondParser par;
994 1.312 rillig CondResult rval;
995 1.10 christos
996 1.215 rillig cpp_skip_hspace(&cond);
997 1.10 christos
998 1.243 rillig par.plain = plain;
999 1.243 rillig par.evalBare = evalBare;
1000 1.243 rillig par.negateEvalBare = negate;
1001 1.277 rillig par.leftUnquotedOK = leftUnquotedOK;
1002 1.215 rillig par.p = cond;
1003 1.215 rillig par.curr = TOK_NONE;
1004 1.260 rillig par.printedError = false;
1005 1.10 christos
1006 1.310 rillig rval = CondParser_Eval(&par);
1007 1.56 dsl
1008 1.311 rillig if (rval == CR_ERROR && eprint && !par.printedError)
1009 1.215 rillig Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", cond);
1010 1.56 dsl
1011 1.215 rillig return rval;
1012 1.56 dsl }
1013 1.56 dsl
1014 1.233 rillig /*
1015 1.233 rillig * Evaluate a condition in a :? modifier, such as
1016 1.233 rillig * ${"${VAR}" == value:?yes:no}.
1017 1.233 rillig */
1018 1.312 rillig CondResult
1019 1.310 rillig Cond_EvalCondition(const char *cond)
1020 1.142 rillig {
1021 1.310 rillig return CondEvalExpression(cond, true,
1022 1.277 rillig FuncDefined, false, false, true);
1023 1.142 rillig }
1024 1.90 rillig
1025 1.260 rillig static bool
1026 1.224 rillig IsEndif(const char *p)
1027 1.224 rillig {
1028 1.224 rillig return p[0] == 'e' && p[1] == 'n' && p[2] == 'd' &&
1029 1.224 rillig p[3] == 'i' && p[4] == 'f' && !ch_isalpha(p[5]);
1030 1.224 rillig }
1031 1.224 rillig
1032 1.260 rillig static bool
1033 1.260 rillig DetermineKindOfConditional(const char **pp, bool *out_plain,
1034 1.297 rillig bool (**out_evalBare)(const char *),
1035 1.260 rillig bool *out_negate)
1036 1.244 rillig {
1037 1.314 rillig const char *p = *pp + 2;
1038 1.244 rillig
1039 1.260 rillig *out_plain = false;
1040 1.244 rillig *out_evalBare = FuncDefined;
1041 1.314 rillig *out_negate = skip_string(&p, "n");
1042 1.314 rillig
1043 1.314 rillig if (skip_string(&p, "def")) { /* .ifdef and .ifndef */
1044 1.314 rillig } else if (skip_string(&p, "make")) /* .ifmake and .ifnmake */
1045 1.244 rillig *out_evalBare = FuncMake;
1046 1.314 rillig else if (!*out_negate) /* plain .if */
1047 1.260 rillig *out_plain = true;
1048 1.314 rillig else
1049 1.314 rillig goto unknown_directive;
1050 1.314 rillig if (ch_isalpha(*p))
1051 1.314 rillig goto unknown_directive;
1052 1.244 rillig
1053 1.244 rillig *pp = p;
1054 1.260 rillig return true;
1055 1.314 rillig
1056 1.314 rillig unknown_directive:
1057 1.314 rillig /*
1058 1.314 rillig * TODO: Add error message about unknown directive, since there is no
1059 1.314 rillig * other known directive that starts with 'el' or 'if'.
1060 1.314 rillig *
1061 1.314 rillig * Example: .elifx 123
1062 1.314 rillig */
1063 1.314 rillig return false;
1064 1.244 rillig }
1065 1.244 rillig
1066 1.233 rillig /*
1067 1.233 rillig * Evaluate the conditional directive in the line, which is one of:
1068 1.207 rillig *
1069 1.206 rillig * .if <cond>
1070 1.206 rillig * .ifmake <cond>
1071 1.206 rillig * .ifnmake <cond>
1072 1.206 rillig * .ifdef <cond>
1073 1.206 rillig * .ifndef <cond>
1074 1.206 rillig * .elif <cond>
1075 1.206 rillig * .elifmake <cond>
1076 1.206 rillig * .elifnmake <cond>
1077 1.206 rillig * .elifdef <cond>
1078 1.206 rillig * .elifndef <cond>
1079 1.206 rillig * .else
1080 1.206 rillig * .endif
1081 1.207 rillig *
1082 1.207 rillig * In these directives, <cond> consists of &&, ||, !, function(arg),
1083 1.207 rillig * comparisons, expressions, bare words, numbers and strings, and
1084 1.207 rillig * parenthetical groupings thereof.
1085 1.1 cgd *
1086 1.108 rillig * Results:
1087 1.311 rillig * CR_TRUE to continue parsing the lines that follow the
1088 1.260 rillig * conditional (when <cond> evaluates to true)
1089 1.311 rillig * CR_FALSE to skip the lines after the conditional
1090 1.260 rillig * (when <cond> evaluates to false, or when a previous
1091 1.108 rillig * branch has already been taken)
1092 1.311 rillig * CR_ERROR if the conditional was not valid, either because of
1093 1.108 rillig * a syntax error or because some variable was undefined
1094 1.108 rillig * or because the condition could not be evaluated
1095 1.1 cgd */
1096 1.312 rillig CondResult
1097 1.222 rillig Cond_EvalLine(const char *line)
1098 1.1 cgd {
1099 1.215 rillig typedef enum IfState {
1100 1.215 rillig
1101 1.260 rillig /* None of the previous <cond> evaluated to true. */
1102 1.215 rillig IFS_INITIAL = 0,
1103 1.215 rillig
1104 1.306 rillig /*
1105 1.306 rillig * The previous <cond> evaluated to true. The lines following
1106 1.306 rillig * this condition are interpreted.
1107 1.306 rillig */
1108 1.215 rillig IFS_ACTIVE = 1 << 0,
1109 1.215 rillig
1110 1.215 rillig /* The previous directive was an '.else'. */
1111 1.215 rillig IFS_SEEN_ELSE = 1 << 1,
1112 1.215 rillig
1113 1.260 rillig /* One of the previous <cond> evaluated to true. */
1114 1.215 rillig IFS_WAS_ACTIVE = 1 << 2
1115 1.207 rillig
1116 1.215 rillig } IfState;
1117 1.213 rillig
1118 1.215 rillig static enum IfState *cond_states = NULL;
1119 1.215 rillig static unsigned int cond_states_cap = 128;
1120 1.215 rillig
1121 1.260 rillig bool plain;
1122 1.297 rillig bool (*evalBare)(const char *);
1123 1.260 rillig bool negate;
1124 1.260 rillig bool isElif;
1125 1.310 rillig CondResult res;
1126 1.215 rillig IfState state;
1127 1.215 rillig const char *p = line;
1128 1.215 rillig
1129 1.215 rillig if (cond_states == NULL) {
1130 1.215 rillig cond_states = bmake_malloc(
1131 1.215 rillig cond_states_cap * sizeof *cond_states);
1132 1.215 rillig cond_states[0] = IFS_ACTIVE;
1133 1.215 rillig }
1134 1.215 rillig
1135 1.215 rillig p++; /* skip the leading '.' */
1136 1.215 rillig cpp_skip_hspace(&p);
1137 1.215 rillig
1138 1.224 rillig if (IsEndif(p)) { /* It is an '.endif'. */
1139 1.225 rillig if (p[5] != '\0') {
1140 1.225 rillig Parse_Error(PARSE_FATAL,
1141 1.282 rillig "The .endif directive does not take arguments");
1142 1.225 rillig }
1143 1.224 rillig
1144 1.224 rillig if (cond_depth == cond_min_depth) {
1145 1.224 rillig Parse_Error(PARSE_FATAL, "if-less endif");
1146 1.311 rillig return CR_TRUE;
1147 1.224 rillig }
1148 1.224 rillig
1149 1.224 rillig /* Return state for previous conditional */
1150 1.224 rillig cond_depth--;
1151 1.224 rillig return cond_states[cond_depth] & IFS_ACTIVE
1152 1.311 rillig ? CR_TRUE : CR_FALSE;
1153 1.224 rillig }
1154 1.224 rillig
1155 1.215 rillig /* Parse the name of the directive, such as 'if', 'elif', 'endif'. */
1156 1.215 rillig if (p[0] == 'e') {
1157 1.215 rillig if (p[1] != 'l') {
1158 1.224 rillig /*
1159 1.224 rillig * Unknown directive. It might still be a
1160 1.281 rillig * transformation rule like '.err.txt',
1161 1.224 rillig * therefore no error message here.
1162 1.224 rillig */
1163 1.311 rillig return CR_ERROR;
1164 1.215 rillig }
1165 1.211 rillig
1166 1.215 rillig /* Quite likely this is 'else' or 'elif' */
1167 1.215 rillig p += 2;
1168 1.314 rillig if (strncmp(p, "se", 2) == 0 && !ch_isalpha(p[2])) {
1169 1.226 rillig if (p[2] != '\0')
1170 1.215 rillig Parse_Error(PARSE_FATAL,
1171 1.282 rillig "The .else directive "
1172 1.282 rillig "does not take arguments");
1173 1.215 rillig
1174 1.215 rillig if (cond_depth == cond_min_depth) {
1175 1.215 rillig Parse_Error(PARSE_FATAL, "if-less else");
1176 1.311 rillig return CR_TRUE;
1177 1.215 rillig }
1178 1.215 rillig
1179 1.215 rillig state = cond_states[cond_depth];
1180 1.215 rillig if (state == IFS_INITIAL) {
1181 1.215 rillig state = IFS_ACTIVE | IFS_SEEN_ELSE;
1182 1.215 rillig } else {
1183 1.215 rillig if (state & IFS_SEEN_ELSE)
1184 1.215 rillig Parse_Error(PARSE_WARNING,
1185 1.305 rillig "extra else");
1186 1.215 rillig state = IFS_WAS_ACTIVE | IFS_SEEN_ELSE;
1187 1.215 rillig }
1188 1.215 rillig cond_states[cond_depth] = state;
1189 1.211 rillig
1190 1.311 rillig return state & IFS_ACTIVE ? CR_TRUE : CR_FALSE;
1191 1.215 rillig }
1192 1.215 rillig /* Assume for now it is an elif */
1193 1.260 rillig isElif = true;
1194 1.215 rillig } else
1195 1.260 rillig isElif = false;
1196 1.211 rillig
1197 1.215 rillig if (p[0] != 'i' || p[1] != 'f') {
1198 1.215 rillig /*
1199 1.215 rillig * Unknown directive. It might still be a transformation rule
1200 1.215 rillig * like '.elisp.scm', therefore no error message here.
1201 1.215 rillig */
1202 1.311 rillig return CR_ERROR; /* Not an ifxxx or elifxxx line */
1203 1.36 dsl }
1204 1.36 dsl
1205 1.244 rillig if (!DetermineKindOfConditional(&p, &plain, &evalBare, &negate))
1206 1.311 rillig return CR_ERROR;
1207 1.206 rillig
1208 1.215 rillig if (isElif) {
1209 1.215 rillig if (cond_depth == cond_min_depth) {
1210 1.215 rillig Parse_Error(PARSE_FATAL, "if-less elif");
1211 1.311 rillig return CR_TRUE;
1212 1.215 rillig }
1213 1.215 rillig state = cond_states[cond_depth];
1214 1.215 rillig if (state & IFS_SEEN_ELSE) {
1215 1.215 rillig Parse_Error(PARSE_WARNING, "extra elif");
1216 1.215 rillig cond_states[cond_depth] =
1217 1.215 rillig IFS_WAS_ACTIVE | IFS_SEEN_ELSE;
1218 1.311 rillig return CR_FALSE;
1219 1.215 rillig }
1220 1.215 rillig if (state != IFS_INITIAL) {
1221 1.215 rillig cond_states[cond_depth] = IFS_WAS_ACTIVE;
1222 1.311 rillig return CR_FALSE;
1223 1.215 rillig }
1224 1.215 rillig } else {
1225 1.215 rillig /* Normal .if */
1226 1.215 rillig if (cond_depth + 1 >= cond_states_cap) {
1227 1.215 rillig /*
1228 1.215 rillig * This is rare, but not impossible.
1229 1.215 rillig * In meta mode, dirdeps.mk (only runs at level 0)
1230 1.215 rillig * can need more than the default.
1231 1.215 rillig */
1232 1.215 rillig cond_states_cap += 32;
1233 1.215 rillig cond_states = bmake_realloc(cond_states,
1234 1.305 rillig cond_states_cap * sizeof *cond_states);
1235 1.215 rillig }
1236 1.215 rillig state = cond_states[cond_depth];
1237 1.215 rillig cond_depth++;
1238 1.215 rillig if (!(state & IFS_ACTIVE)) {
1239 1.215 rillig /*
1240 1.215 rillig * If we aren't parsing the data,
1241 1.215 rillig * treat as always false.
1242 1.215 rillig */
1243 1.215 rillig cond_states[cond_depth] = IFS_WAS_ACTIVE;
1244 1.311 rillig return CR_FALSE;
1245 1.215 rillig }
1246 1.215 rillig }
1247 1.215 rillig
1248 1.215 rillig /* And evaluate the conditional expression */
1249 1.310 rillig res = CondEvalExpression(p, plain, evalBare, negate, true, false);
1250 1.311 rillig if (res == CR_ERROR) {
1251 1.324 rillig /* Syntax error, error message already output. */
1252 1.324 rillig /* Skip everything to the matching '.endif'. */
1253 1.324 rillig /* An extra '.else' is not detected in this case. */
1254 1.215 rillig cond_states[cond_depth] = IFS_WAS_ACTIVE;
1255 1.311 rillig return CR_FALSE;
1256 1.215 rillig }
1257 1.215 rillig
1258 1.313 rillig cond_states[cond_depth] = res == CR_TRUE ? IFS_ACTIVE : IFS_INITIAL;
1259 1.313 rillig return res;
1260 1.1 cgd }
1261 1.10 christos
1262 1.1 cgd void
1263 1.37 dsl Cond_restore_depth(unsigned int saved_depth)
1264 1.1 cgd {
1265 1.215 rillig unsigned int open_conds = cond_depth - cond_min_depth;
1266 1.37 dsl
1267 1.215 rillig if (open_conds != 0 || saved_depth > cond_depth) {
1268 1.215 rillig Parse_Error(PARSE_FATAL, "%u open conditional%s",
1269 1.305 rillig open_conds, open_conds == 1 ? "" : "s");
1270 1.215 rillig cond_depth = cond_min_depth;
1271 1.215 rillig }
1272 1.37 dsl
1273 1.215 rillig cond_min_depth = saved_depth;
1274 1.37 dsl }
1275 1.37 dsl
1276 1.37 dsl unsigned int
1277 1.37 dsl Cond_save_depth(void)
1278 1.37 dsl {
1279 1.215 rillig unsigned int depth = cond_min_depth;
1280 1.37 dsl
1281 1.215 rillig cond_min_depth = cond_depth;
1282 1.215 rillig return depth;
1283 1.1 cgd }
1284