cond.c revision 1.211 1 1.211 rillig /* $NetBSD: cond.c,v 1.211 2020/11/13 06:19:27 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.117 rillig /* Handling of conditionals in a makefile.
73 1.1 cgd *
74 1.1 cgd * Interface:
75 1.209 rillig * Cond_EvalLine Evaluate the conditional directive, such as
76 1.209 rillig * '.if <cond>', '.elifnmake <cond>', '.else', '.endif'.
77 1.1 cgd *
78 1.142 rillig * Cond_EvalCondition
79 1.168 rillig * Evaluate the conditional, which is either the argument
80 1.168 rillig * of one of the .if directives or the condition in a
81 1.168 rillig * ':?then:else' variable modifier.
82 1.117 rillig *
83 1.117 rillig * Cond_save_depth
84 1.117 rillig * Cond_restore_depth
85 1.117 rillig * Save and restore the nesting of the conditions, at
86 1.117 rillig * the start and end of including another makefile, to
87 1.117 rillig * ensure that in each makefile the conditional
88 1.117 rillig * directives are well-balanced.
89 1.1 cgd */
90 1.1 cgd
91 1.99 rillig #include <errno.h>
92 1.99 rillig
93 1.99 rillig #include "make.h"
94 1.99 rillig #include "dir.h"
95 1.1 cgd
96 1.144 rillig /* "@(#)cond.c 8.2 (Berkeley) 1/2/94" */
97 1.211 rillig MAKE_RCSID("$NetBSD: cond.c,v 1.211 2020/11/13 06:19:27 rillig Exp $");
98 1.144 rillig
99 1.1 cgd /*
100 1.1 cgd * The parsing of conditional expressions is based on this grammar:
101 1.1 cgd * E -> F || E
102 1.1 cgd * E -> F
103 1.1 cgd * F -> T && F
104 1.1 cgd * F -> T
105 1.1 cgd * T -> defined(variable)
106 1.1 cgd * T -> make(target)
107 1.1 cgd * T -> exists(file)
108 1.1 cgd * T -> empty(varspec)
109 1.1 cgd * T -> target(name)
110 1.12 christos * T -> commands(name)
111 1.1 cgd * T -> symbol
112 1.1 cgd * T -> $(varspec) op value
113 1.1 cgd * T -> $(varspec) == "string"
114 1.1 cgd * T -> $(varspec) != "string"
115 1.23 sjg * T -> "string"
116 1.1 cgd * T -> ( E )
117 1.1 cgd * T -> ! T
118 1.1 cgd * op -> == | != | > | < | >= | <=
119 1.1 cgd *
120 1.96 rillig * 'symbol' is some other symbol to which the default function is applied.
121 1.1 cgd *
122 1.121 rillig * The tokens are scanned by CondToken, which returns:
123 1.121 rillig * TOK_AND for '&' or '&&'
124 1.121 rillig * TOK_OR for '|' or '||'
125 1.121 rillig * TOK_NOT for '!'
126 1.121 rillig * TOK_LPAREN for '('
127 1.121 rillig * TOK_RPAREN for ')'
128 1.121 rillig * Other terminal symbols are evaluated using either the default function or
129 1.121 rillig * the function given in the terminal, they return either TOK_TRUE or
130 1.121 rillig * TOK_FALSE.
131 1.1 cgd *
132 1.60 dsl * TOK_FALSE is 0 and TOK_TRUE 1 so we can directly assign C comparisons.
133 1.60 dsl *
134 1.125 rillig * All non-terminal functions (CondParser_Expr, CondParser_Factor and
135 1.125 rillig * CondParser_Term) return either TOK_FALSE, TOK_TRUE, or TOK_ERROR on error.
136 1.1 cgd */
137 1.164 rillig typedef enum Token {
138 1.60 dsl TOK_FALSE = 0, TOK_TRUE = 1, TOK_AND, TOK_OR, TOK_NOT,
139 1.60 dsl TOK_LPAREN, TOK_RPAREN, TOK_EOF, TOK_NONE, TOK_ERROR
140 1.1 cgd } Token;
141 1.1 cgd
142 1.150 rillig typedef struct CondParser {
143 1.114 rillig const struct If *if_info; /* Info for current statement */
144 1.122 rillig const char *p; /* The remaining condition to parse */
145 1.115 rillig Token curr; /* Single push-back token used in parsing */
146 1.146 rillig
147 1.146 rillig /* Whether an error message has already been printed for this condition.
148 1.146 rillig * The first available error message is usually the most specific one,
149 1.146 rillig * therefore it makes sense to suppress the standard "Malformed
150 1.146 rillig * conditional" message. */
151 1.146 rillig Boolean printedError;
152 1.121 rillig } CondParser;
153 1.1 cgd
154 1.125 rillig static Token CondParser_Expr(CondParser *par, Boolean);
155 1.1 cgd
156 1.93 rillig static unsigned int cond_depth = 0; /* current .if nesting level */
157 1.93 rillig static unsigned int cond_min_depth = 0; /* depth at makefile open */
158 1.1 cgd
159 1.68 sjg /*
160 1.68 sjg * Indicate when we should be strict about lhs of comparisons.
161 1.117 rillig * In strict mode, the lhs must be a variable expression or a string literal
162 1.117 rillig * in quotes. In non-strict mode it may also be an unquoted string literal.
163 1.117 rillig *
164 1.142 rillig * TRUE when CondEvalExpression is called from Cond_EvalLine (.if etc)
165 1.142 rillig * FALSE when CondEvalExpression is called from ApplyModifier_IfElse
166 1.180 rillig * since lhs is already expanded, and at that point we cannot tell if
167 1.68 sjg * it was a variable reference or not.
168 1.68 sjg */
169 1.68 sjg static Boolean lhsStrict;
170 1.68 sjg
171 1.26 christos static int
172 1.125 rillig is_token(const char *str, const char *tok, size_t len)
173 1.26 christos {
174 1.134 rillig return strncmp(str, tok, len) == 0 && !ch_isalpha(str[len]);
175 1.26 christos }
176 1.26 christos
177 1.183 rillig static Token
178 1.183 rillig ToToken(Boolean cond)
179 1.183 rillig {
180 1.183 rillig return cond ? TOK_TRUE : TOK_FALSE;
181 1.183 rillig }
182 1.183 rillig
183 1.115 rillig /* Push back the most recent token read. We only need one level of this. */
184 1.1 cgd static void
185 1.121 rillig CondParser_PushBack(CondParser *par, Token t)
186 1.1 cgd {
187 1.121 rillig assert(par->curr == TOK_NONE);
188 1.115 rillig assert(t != TOK_NONE);
189 1.115 rillig
190 1.121 rillig par->curr = t;
191 1.1 cgd }
192 1.90 rillig
193 1.116 rillig static void
194 1.121 rillig CondParser_SkipWhitespace(CondParser *par)
195 1.116 rillig {
196 1.160 rillig cpp_skip_whitespace(&par->p);
197 1.116 rillig }
198 1.116 rillig
199 1.112 rillig /* Parse the argument of a built-in function.
200 1.112 rillig *
201 1.112 rillig * Arguments:
202 1.149 rillig * *pp initially points at the '(',
203 1.149 rillig * upon successful return it points right after the ')'.
204 1.112 rillig *
205 1.112 rillig * *out_arg receives the argument as string.
206 1.112 rillig *
207 1.112 rillig * func says whether the argument belongs to an actual function, or
208 1.112 rillig * whether the parsed argument is passed to the default function.
209 1.112 rillig *
210 1.181 rillig * Return the length of the argument, or 0 on error. */
211 1.161 rillig static size_t
212 1.149 rillig ParseFuncArg(const char **pp, Boolean doEval, const char *func,
213 1.127 rillig char **out_arg) {
214 1.149 rillig const char *p = *pp;
215 1.149 rillig Buffer argBuf;
216 1.93 rillig int paren_depth;
217 1.93 rillig size_t argLen;
218 1.1 cgd
219 1.56 dsl if (func != NULL)
220 1.149 rillig p++; /* Skip opening '(' - verified by caller */
221 1.1 cgd
222 1.149 rillig if (*p == '\0') {
223 1.201 rillig *out_arg = NULL; /* Missing closing parenthesis: */
224 1.201 rillig return 0; /* .if defined( */
225 1.1 cgd }
226 1.1 cgd
227 1.177 rillig cpp_skip_hspace(&p);
228 1.1 cgd
229 1.179 rillig Buf_InitSize(&argBuf, 16);
230 1.7 christos
231 1.56 dsl paren_depth = 0;
232 1.56 dsl for (;;) {
233 1.149 rillig char ch = *p;
234 1.178 rillig if (ch == '\0' || ch == ' ' || ch == '\t')
235 1.56 dsl break;
236 1.56 dsl if ((ch == '&' || ch == '|') && paren_depth == 0)
237 1.56 dsl break;
238 1.149 rillig if (*p == '$') {
239 1.1 cgd /*
240 1.1 cgd * Parse the variable spec and install it as part of the argument
241 1.1 cgd * if it's valid. We tell Var_Parse to complain on an undefined
242 1.117 rillig * variable, so we don't need to do it. Nor do we return an error,
243 1.1 cgd * though perhaps we should...
244 1.1 cgd */
245 1.151 rillig void *nestedVal_freeIt;
246 1.186 rillig VarEvalFlags eflags = doEval ? VARE_WANTRES | VARE_UNDEFERR
247 1.186 rillig : VARE_NONE;
248 1.151 rillig const char *nestedVal;
249 1.170 rillig (void)Var_Parse(&p, VAR_CMDLINE, eflags, &nestedVal,
250 1.170 rillig &nestedVal_freeIt);
251 1.145 rillig /* TODO: handle errors */
252 1.151 rillig Buf_AddStr(&argBuf, nestedVal);
253 1.151 rillig free(nestedVal_freeIt);
254 1.56 dsl continue;
255 1.1 cgd }
256 1.56 dsl if (ch == '(')
257 1.56 dsl paren_depth++;
258 1.93 rillig else if (ch == ')' && --paren_depth < 0)
259 1.93 rillig break;
260 1.149 rillig Buf_AddByte(&argBuf, *p);
261 1.149 rillig p++;
262 1.1 cgd }
263 1.1 cgd
264 1.149 rillig *out_arg = Buf_GetAll(&argBuf, &argLen);
265 1.149 rillig Buf_Destroy(&argBuf, FALSE);
266 1.1 cgd
267 1.177 rillig cpp_skip_hspace(&p);
268 1.56 dsl
269 1.149 rillig if (func != NULL && *p++ != ')') {
270 1.25 christos Parse_Error(PARSE_WARNING, "Missing closing parenthesis for %s()",
271 1.93 rillig func);
272 1.142 rillig /* The PARSE_FATAL is done as a follow-up by CondEvalExpression. */
273 1.77 rillig return 0;
274 1.50 dsl }
275 1.50 dsl
276 1.149 rillig *pp = p;
277 1.77 rillig return argLen;
278 1.1 cgd }
279 1.90 rillig
280 1.90 rillig /* Test whether the given variable is defined. */
281 1.1 cgd static Boolean
282 1.161 rillig FuncDefined(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
283 1.1 cgd {
284 1.173 rillig void *freeIt;
285 1.170 rillig Boolean result = Var_Value(arg, VAR_CMDLINE, &freeIt) != NULL;
286 1.84 rillig bmake_free(freeIt);
287 1.77 rillig return result;
288 1.1 cgd }
289 1.90 rillig
290 1.90 rillig /* See if the given target is being made. */
291 1.1 cgd static Boolean
292 1.161 rillig FuncMake(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
293 1.1 cgd {
294 1.166 rillig StringListNode *ln;
295 1.166 rillig
296 1.169 rillig for (ln = opts.create->first; ln != NULL; ln = ln->next)
297 1.166 rillig if (Str_Match(ln->datum, arg))
298 1.166 rillig return TRUE;
299 1.166 rillig return FALSE;
300 1.1 cgd }
301 1.90 rillig
302 1.90 rillig /* See if the given file exists. */
303 1.1 cgd static Boolean
304 1.161 rillig FuncExists(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
305 1.1 cgd {
306 1.1 cgd Boolean result;
307 1.93 rillig char *path;
308 1.1 cgd
309 1.1 cgd path = Dir_FindFile(arg, dirSearchPath);
310 1.188 rillig DEBUG2(COND, "exists(%s) result is \"%s\"\n",
311 1.188 rillig arg, path != NULL ? path : "");
312 1.188 rillig result = path != NULL;
313 1.188 rillig free(path);
314 1.77 rillig return result;
315 1.1 cgd }
316 1.90 rillig
317 1.90 rillig /* See if the given node exists and is an actual target. */
318 1.1 cgd static Boolean
319 1.161 rillig FuncTarget(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
320 1.1 cgd {
321 1.152 rillig GNode *gn = Targ_FindNode(arg);
322 1.167 rillig return gn != NULL && GNode_IsTarget(gn);
323 1.1 cgd }
324 1.1 cgd
325 1.90 rillig /* See if the given node exists and is an actual target with commands
326 1.90 rillig * associated with it. */
327 1.12 christos static Boolean
328 1.161 rillig FuncCommands(size_t argLen MAKE_ATTR_UNUSED, const char *arg)
329 1.12 christos {
330 1.152 rillig GNode *gn = Targ_FindNode(arg);
331 1.167 rillig return gn != NULL && GNode_IsTarget(gn) && !Lst_IsEmpty(gn->commands);
332 1.12 christos }
333 1.90 rillig
334 1.189 rillig /*
335 1.90 rillig * Convert the given number into a double.
336 1.90 rillig * We try a base 10 or 16 integer conversion first, if that fails
337 1.90 rillig * then we try a floating point conversion instead.
338 1.1 cgd *
339 1.1 cgd * Results:
340 1.90 rillig * Returns TRUE if the conversion succeeded.
341 1.189 rillig * Sets 'out_value' to the converted number.
342 1.1 cgd */
343 1.46 dsl static Boolean
344 1.189 rillig TryParseNumber(const char *str, double *out_value)
345 1.1 cgd {
346 1.189 rillig char *end;
347 1.189 rillig unsigned long ul_val;
348 1.189 rillig double dbl_val;
349 1.46 dsl
350 1.71 sjg errno = 0;
351 1.189 rillig if (str[0] == '\0') { /* XXX: why is an empty string a number? */
352 1.189 rillig *out_value = 0.0;
353 1.71 sjg return TRUE;
354 1.70 sjg }
355 1.189 rillig
356 1.189 rillig ul_val = strtoul(str, &end, str[1] == 'x' ? 16 : 10);
357 1.189 rillig if (*end == '\0' && errno != ERANGE) {
358 1.189 rillig *out_value = str[0] == '-' ? -(double)-ul_val : (double)ul_val;
359 1.189 rillig return TRUE;
360 1.1 cgd }
361 1.46 dsl
362 1.189 rillig if (*end != '\0' && *end != '.' && *end != 'e' && *end != 'E')
363 1.189 rillig return FALSE; /* skip the expensive strtod call */
364 1.189 rillig dbl_val = strtod(str, &end);
365 1.189 rillig if (*end != '\0')
366 1.189 rillig return FALSE;
367 1.189 rillig
368 1.189 rillig *out_value = dbl_val;
369 1.46 dsl return TRUE;
370 1.1 cgd }
371 1.46 dsl
372 1.140 rillig static Boolean
373 1.140 rillig is_separator(char ch)
374 1.140 rillig {
375 1.172 rillig return ch == '\0' || ch_isspace(ch) || strchr("!=><)", ch) != NULL;
376 1.140 rillig }
377 1.140 rillig
378 1.1 cgd /*-
379 1.117 rillig * Parse a string from a variable reference or an optionally quoted
380 1.124 rillig * string. This is called for the lhs and rhs of string comparisons.
381 1.23 sjg *
382 1.23 sjg * Results:
383 1.90 rillig * Returns the string, absent any quotes, or NULL on error.
384 1.178 rillig * Sets out_quoted if the string was quoted.
385 1.178 rillig * Sets out_freeIt.
386 1.23 sjg */
387 1.147 rillig /* coverity:[+alloc : arg-*4] */
388 1.82 rillig static const char *
389 1.124 rillig CondParser_String(CondParser *par, Boolean doEval, Boolean strictLHS,
390 1.178 rillig Boolean *out_quoted, void **out_freeIt)
391 1.23 sjg {
392 1.23 sjg Buffer buf;
393 1.82 rillig const char *str;
394 1.140 rillig Boolean atStart;
395 1.140 rillig const char *nested_p;
396 1.190 rillig Boolean quoted;
397 1.91 rillig const char *start;
398 1.98 rillig VarEvalFlags eflags;
399 1.148 rillig VarParseResult parseResult;
400 1.23 sjg
401 1.179 rillig Buf_Init(&buf);
402 1.23 sjg str = NULL;
403 1.178 rillig *out_freeIt = NULL;
404 1.190 rillig *out_quoted = quoted = par->p[0] == '"';
405 1.171 rillig start = par->p;
406 1.190 rillig if (quoted)
407 1.122 rillig par->p++;
408 1.178 rillig while (par->p[0] != '\0' && str == NULL) {
409 1.123 rillig switch (par->p[0]) {
410 1.23 sjg case '\\':
411 1.122 rillig par->p++;
412 1.122 rillig if (par->p[0] != '\0') {
413 1.123 rillig Buf_AddByte(&buf, par->p[0]);
414 1.122 rillig par->p++;
415 1.23 sjg }
416 1.119 rillig continue;
417 1.23 sjg case '"':
418 1.190 rillig if (quoted) {
419 1.190 rillig par->p++; /* skip the closing quote */
420 1.23 sjg goto got_str;
421 1.120 rillig }
422 1.123 rillig Buf_AddByte(&buf, par->p[0]); /* likely? */
423 1.122 rillig par->p++;
424 1.119 rillig continue;
425 1.190 rillig case ')': /* see is_separator */
426 1.23 sjg case '!':
427 1.23 sjg case '=':
428 1.23 sjg case '>':
429 1.23 sjg case '<':
430 1.23 sjg case ' ':
431 1.23 sjg case '\t':
432 1.190 rillig if (!quoted)
433 1.23 sjg goto got_str;
434 1.123 rillig Buf_AddByte(&buf, par->p[0]);
435 1.122 rillig par->p++;
436 1.119 rillig continue;
437 1.23 sjg case '$':
438 1.140 rillig /* if we are in quotes, an undefined variable is ok */
439 1.190 rillig eflags = doEval && !quoted ? VARE_WANTRES | VARE_UNDEFERR :
440 1.184 rillig doEval ? VARE_WANTRES :
441 1.184 rillig VARE_NONE;
442 1.184 rillig
443 1.140 rillig nested_p = par->p;
444 1.140 rillig atStart = nested_p == start;
445 1.170 rillig parseResult = Var_Parse(&nested_p, VAR_CMDLINE, eflags, &str,
446 1.178 rillig out_freeIt);
447 1.145 rillig /* TODO: handle errors */
448 1.23 sjg if (str == var_Error) {
449 1.163 rillig if (parseResult & VPR_ANY_MSG)
450 1.163 rillig par->printedError = TRUE;
451 1.190 rillig if (*out_freeIt != NULL) {
452 1.203 rillig /* XXX: Can there be any situation in which a returned
453 1.203 rillig * var_Error requires freeIt? */
454 1.178 rillig free(*out_freeIt);
455 1.178 rillig *out_freeIt = NULL;
456 1.30 christos }
457 1.23 sjg /*
458 1.23 sjg * Even if !doEval, we still report syntax errors, which
459 1.23 sjg * is what getting var_Error back with !doEval means.
460 1.23 sjg */
461 1.23 sjg str = NULL;
462 1.23 sjg goto cleanup;
463 1.23 sjg }
464 1.140 rillig par->p = nested_p;
465 1.140 rillig
466 1.23 sjg /*
467 1.140 rillig * If the '$' started the string literal (which means no quotes),
468 1.140 rillig * and the variable expression is followed by a space, looks like
469 1.140 rillig * a comparison operator or is the end of the expression, we are
470 1.140 rillig * done.
471 1.23 sjg */
472 1.140 rillig if (atStart && is_separator(par->p[0]))
473 1.23 sjg goto cleanup;
474 1.113 rillig
475 1.113 rillig Buf_AddStr(&buf, str);
476 1.178 rillig if (*out_freeIt) {
477 1.178 rillig free(*out_freeIt);
478 1.178 rillig *out_freeIt = NULL;
479 1.30 christos }
480 1.93 rillig str = NULL; /* not finished yet */
481 1.119 rillig continue;
482 1.23 sjg default:
483 1.190 rillig if (strictLHS && !quoted && *start != '$' && !ch_isdigit(*start)) {
484 1.68 sjg /* lhs must be quoted, a variable reference or number */
485 1.68 sjg str = NULL;
486 1.68 sjg goto cleanup;
487 1.68 sjg }
488 1.123 rillig Buf_AddByte(&buf, par->p[0]);
489 1.122 rillig par->p++;
490 1.119 rillig continue;
491 1.23 sjg }
492 1.23 sjg }
493 1.93 rillig got_str:
494 1.178 rillig *out_freeIt = Buf_GetAll(&buf, NULL);
495 1.178 rillig str = *out_freeIt;
496 1.93 rillig cleanup:
497 1.50 dsl Buf_Destroy(&buf, FALSE);
498 1.23 sjg return str;
499 1.23 sjg }
500 1.89 rillig
501 1.176 rillig struct If {
502 1.93 rillig const char *form; /* Form of if */
503 1.97 rillig size_t formlen; /* Length of form */
504 1.93 rillig Boolean doNot; /* TRUE if default function should be negated */
505 1.161 rillig Boolean (*defProc)(size_t, const char *); /* Default function to apply */
506 1.176 rillig };
507 1.176 rillig
508 1.176 rillig /* The different forms of .if directives. */
509 1.176 rillig static const struct If ifs[] = {
510 1.125 rillig { "def", 3, FALSE, FuncDefined },
511 1.125 rillig { "ndef", 4, TRUE, FuncDefined },
512 1.125 rillig { "make", 4, FALSE, FuncMake },
513 1.125 rillig { "nmake", 5, TRUE, FuncMake },
514 1.125 rillig { "", 0, FALSE, FuncDefined },
515 1.93 rillig { NULL, 0, FALSE, NULL }
516 1.89 rillig };
517 1.208 rillig enum { PLAIN_IF_INDEX = 4 };
518 1.89 rillig
519 1.176 rillig static Boolean
520 1.176 rillig If_Eval(const struct If *if_info, const char *arg, size_t arglen)
521 1.176 rillig {
522 1.176 rillig Boolean res = if_info->defProc(arglen, arg);
523 1.182 rillig return if_info->doNot ? !res : res;
524 1.176 rillig }
525 1.176 rillig
526 1.131 rillig /* Evaluate a "comparison without operator", such as in ".if ${VAR}" or
527 1.131 rillig * ".if 0". */
528 1.183 rillig static Boolean
529 1.191 rillig EvalNotEmpty(CondParser *par, const char *value, Boolean quoted)
530 1.131 rillig {
531 1.192 rillig double num;
532 1.131 rillig
533 1.191 rillig /* For .ifxxx "...", check for non-empty string. */
534 1.191 rillig if (quoted)
535 1.191 rillig return value[0] != '\0';
536 1.131 rillig
537 1.191 rillig /* For .ifxxx <number>, compare against zero */
538 1.192 rillig if (TryParseNumber(value, &num))
539 1.192 rillig return num != 0.0;
540 1.131 rillig
541 1.205 rillig /* For .if ${...}, check for non-empty string. This is different from
542 1.205 rillig * the evaluation function from that .if variant, which would test
543 1.205 rillig * whether a variable of the given name were defined. */
544 1.205 rillig /* XXX: Whitespace should count as empty, just as in ParseEmptyArg. */
545 1.131 rillig if (par->if_info->form[0] == '\0')
546 1.191 rillig return value[0] != '\0';
547 1.131 rillig
548 1.204 rillig /* For the other variants of .ifxxx ${...}, use its default function. */
549 1.191 rillig return If_Eval(par->if_info, value, strlen(value));
550 1.131 rillig }
551 1.131 rillig
552 1.133 rillig /* Evaluate a numerical comparison, such as in ".if ${VAR} >= 9". */
553 1.130 rillig static Token
554 1.133 rillig EvalCompareNum(double lhs, const char *op, double rhs)
555 1.130 rillig {
556 1.154 rillig DEBUG3(COND, "lhs = %f, rhs = %f, op = %.2s\n", lhs, rhs, op);
557 1.130 rillig
558 1.130 rillig switch (op[0]) {
559 1.130 rillig case '!':
560 1.130 rillig if (op[1] != '=') {
561 1.132 rillig Parse_Error(PARSE_WARNING, "Unknown operator");
562 1.142 rillig /* The PARSE_FATAL is done as a follow-up by CondEvalExpression. */
563 1.130 rillig return TOK_ERROR;
564 1.130 rillig }
565 1.183 rillig return ToToken(lhs != rhs);
566 1.130 rillig case '=':
567 1.130 rillig if (op[1] != '=') {
568 1.132 rillig Parse_Error(PARSE_WARNING, "Unknown operator");
569 1.142 rillig /* The PARSE_FATAL is done as a follow-up by CondEvalExpression. */
570 1.130 rillig return TOK_ERROR;
571 1.130 rillig }
572 1.183 rillig return ToToken(lhs == rhs);
573 1.130 rillig case '<':
574 1.183 rillig return ToToken(op[1] == '=' ? lhs <= rhs : lhs < rhs);
575 1.130 rillig case '>':
576 1.183 rillig return ToToken(op[1] == '=' ? lhs >= rhs : lhs > rhs);
577 1.130 rillig }
578 1.130 rillig return TOK_ERROR;
579 1.130 rillig }
580 1.130 rillig
581 1.133 rillig static Token
582 1.133 rillig EvalCompareStr(const char *lhs, const char *op, const char *rhs)
583 1.133 rillig {
584 1.135 rillig if (!((op[0] == '!' || op[0] == '=') && op[1] == '=')) {
585 1.133 rillig Parse_Error(PARSE_WARNING,
586 1.135 rillig "String comparison operator must be either == or !=");
587 1.142 rillig /* The PARSE_FATAL is done as a follow-up by CondEvalExpression. */
588 1.133 rillig return TOK_ERROR;
589 1.133 rillig }
590 1.133 rillig
591 1.154 rillig DEBUG3(COND, "lhs = \"%s\", rhs = \"%s\", op = %.2s\n", lhs, rhs, op);
592 1.183 rillig return ToToken((*op == '=') == (strcmp(lhs, rhs) == 0));
593 1.133 rillig }
594 1.133 rillig
595 1.133 rillig /* Evaluate a comparison, such as "${VAR} == 12345". */
596 1.133 rillig static Token
597 1.133 rillig EvalCompare(const char *lhs, Boolean lhsQuoted, const char *op,
598 1.133 rillig const char *rhs, Boolean rhsQuoted)
599 1.133 rillig {
600 1.133 rillig double left, right;
601 1.133 rillig
602 1.133 rillig if (!rhsQuoted && !lhsQuoted)
603 1.133 rillig if (TryParseNumber(lhs, &left) && TryParseNumber(rhs, &right))
604 1.133 rillig return EvalCompareNum(left, op, right);
605 1.133 rillig
606 1.133 rillig return EvalCompareStr(lhs, op, rhs);
607 1.133 rillig }
608 1.133 rillig
609 1.129 rillig /* Parse a comparison condition such as:
610 1.129 rillig *
611 1.129 rillig * 0
612 1.129 rillig * ${VAR:Mpattern}
613 1.129 rillig * ${VAR} == value
614 1.129 rillig * ${VAR:U0} < 12345
615 1.129 rillig */
616 1.1 cgd static Token
617 1.125 rillig CondParser_Comparison(CondParser *par, Boolean doEval)
618 1.44 dsl {
619 1.132 rillig Token t = TOK_ERROR;
620 1.132 rillig const char *lhs, *op, *rhs;
621 1.185 rillig void *lhs_freeIt, *rhs_freeIt;
622 1.132 rillig Boolean lhsQuoted, rhsQuoted;
623 1.44 dsl
624 1.44 dsl /*
625 1.44 dsl * Parse the variable spec and skip over it, saving its
626 1.44 dsl * value in lhs.
627 1.44 dsl */
628 1.185 rillig lhs = CondParser_String(par, doEval, lhsStrict, &lhsQuoted, &lhs_freeIt);
629 1.185 rillig if (lhs == NULL)
630 1.185 rillig goto done_lhs;
631 1.58 dsl
632 1.121 rillig CondParser_SkipWhitespace(par);
633 1.44 dsl
634 1.122 rillig op = par->p;
635 1.123 rillig switch (par->p[0]) {
636 1.93 rillig case '!':
637 1.93 rillig case '=':
638 1.93 rillig case '<':
639 1.93 rillig case '>':
640 1.185 rillig if (par->p[1] == '=')
641 1.122 rillig par->p += 2;
642 1.185 rillig else
643 1.155 rillig par->p++;
644 1.93 rillig break;
645 1.93 rillig default:
646 1.185 rillig /* Unknown operator, compare against an empty string or 0. */
647 1.185 rillig t = ToToken(doEval && EvalNotEmpty(par, lhs, lhsQuoted));
648 1.185 rillig goto done_lhs;
649 1.58 dsl }
650 1.44 dsl
651 1.121 rillig CondParser_SkipWhitespace(par);
652 1.58 dsl
653 1.123 rillig if (par->p[0] == '\0') {
654 1.132 rillig Parse_Error(PARSE_WARNING, "Missing right-hand-side of operator");
655 1.142 rillig /* The PARSE_FATAL is done as a follow-up by CondEvalExpression. */
656 1.185 rillig goto done_lhs;
657 1.44 dsl }
658 1.58 dsl
659 1.185 rillig rhs = CondParser_String(par, doEval, FALSE, &rhsQuoted, &rhs_freeIt);
660 1.132 rillig if (rhs == NULL)
661 1.185 rillig goto done_rhs;
662 1.58 dsl
663 1.79 sjg if (!doEval) {
664 1.79 sjg t = TOK_FALSE;
665 1.185 rillig goto done_rhs;
666 1.79 sjg }
667 1.79 sjg
668 1.133 rillig t = EvalCompare(lhs, lhsQuoted, op, rhs, rhsQuoted);
669 1.58 dsl
670 1.185 rillig done_rhs:
671 1.185 rillig free(rhs_freeIt);
672 1.185 rillig done_lhs:
673 1.185 rillig free(lhs_freeIt);
674 1.44 dsl return t;
675 1.44 dsl }
676 1.44 dsl
677 1.200 rillig /* The argument to empty() is a variable name, optionally followed by
678 1.200 rillig * variable modifiers. */
679 1.161 rillig static size_t
680 1.174 rillig ParseEmptyArg(const char **pp, Boolean doEval,
681 1.174 rillig const char *func MAKE_ATTR_UNUSED, char **out_arg)
682 1.47 dsl {
683 1.106 rillig void *val_freeIt;
684 1.82 rillig const char *val;
685 1.161 rillig size_t magic_res;
686 1.47 dsl
687 1.47 dsl /* We do all the work here and return the result as the length */
688 1.174 rillig *out_arg = NULL;
689 1.47 dsl
690 1.174 rillig (*pp)--; /* Make (*pp)[1] point to the '('. */
691 1.183 rillig (void)Var_Parse(pp, VAR_CMDLINE, doEval ? VARE_WANTRES : VARE_NONE,
692 1.145 rillig &val, &val_freeIt);
693 1.145 rillig /* TODO: handle errors */
694 1.174 rillig /* If successful, *pp points beyond the closing ')' now. */
695 1.47 dsl
696 1.47 dsl if (val == var_Error) {
697 1.106 rillig free(val_freeIt);
698 1.161 rillig return (size_t)-1;
699 1.47 dsl }
700 1.47 dsl
701 1.47 dsl /* A variable is empty when it just contains spaces... 4/15/92, christos */
702 1.160 rillig cpp_skip_whitespace(&val);
703 1.47 dsl
704 1.47 dsl /*
705 1.47 dsl * For consistency with the other functions we can't generate the
706 1.47 dsl * true/false here.
707 1.47 dsl */
708 1.111 rillig magic_res = *val != '\0' ? 2 : 1;
709 1.106 rillig free(val_freeIt);
710 1.111 rillig return magic_res;
711 1.47 dsl }
712 1.47 dsl
713 1.47 dsl static Boolean
714 1.161 rillig FuncEmpty(size_t arglen, const char *arg MAKE_ATTR_UNUSED)
715 1.47 dsl {
716 1.112 rillig /* Magic values ahead, see ParseEmptyArg. */
717 1.47 dsl return arglen == 1;
718 1.47 dsl }
719 1.47 dsl
720 1.196 rillig static Boolean
721 1.196 rillig CondParser_Func(CondParser *par, Boolean doEval, Token *out_token)
722 1.44 dsl {
723 1.47 dsl static const struct fn_def {
724 1.93 rillig const char *fn_name;
725 1.97 rillig size_t fn_name_len;
726 1.161 rillig size_t (*fn_parse)(const char **, Boolean, const char *, char **);
727 1.161 rillig Boolean (*fn_eval)(size_t, const char *);
728 1.199 rillig } fns[] = {
729 1.125 rillig { "defined", 7, ParseFuncArg, FuncDefined },
730 1.125 rillig { "make", 4, ParseFuncArg, FuncMake },
731 1.125 rillig { "exists", 6, ParseFuncArg, FuncExists },
732 1.125 rillig { "empty", 5, ParseEmptyArg, FuncEmpty },
733 1.125 rillig { "target", 6, ParseFuncArg, FuncTarget },
734 1.199 rillig { "commands", 8, ParseFuncArg, FuncCommands }
735 1.47 dsl };
736 1.199 rillig const struct fn_def *fn;
737 1.93 rillig char *arg = NULL;
738 1.161 rillig size_t arglen;
739 1.122 rillig const char *cp = par->p;
740 1.199 rillig const struct fn_def *fns_end = fns + sizeof fns / sizeof fns[0];
741 1.44 dsl
742 1.199 rillig for (fn = fns; fn != fns_end; fn++) {
743 1.199 rillig if (!is_token(cp, fn->fn_name, fn->fn_name_len))
744 1.47 dsl continue;
745 1.196 rillig
746 1.199 rillig cp += fn->fn_name_len;
747 1.160 rillig cpp_skip_whitespace(&cp);
748 1.47 dsl if (*cp != '(')
749 1.47 dsl break;
750 1.44 dsl
751 1.199 rillig arglen = fn->fn_parse(&cp, doEval, fn->fn_name, &arg);
752 1.161 rillig if (arglen == 0 || arglen == (size_t)-1) {
753 1.122 rillig par->p = cp;
754 1.196 rillig *out_token = arglen == 0 ? TOK_FALSE : TOK_ERROR;
755 1.196 rillig return TRUE;
756 1.44 dsl }
757 1.200 rillig
758 1.47 dsl /* Evaluate the argument using the required function. */
759 1.199 rillig *out_token = ToToken(!doEval || fn->fn_eval(arglen, arg));
760 1.73 christos free(arg);
761 1.122 rillig par->p = cp;
762 1.196 rillig return TRUE;
763 1.196 rillig }
764 1.196 rillig
765 1.196 rillig return FALSE;
766 1.196 rillig }
767 1.196 rillig
768 1.196 rillig /* Parse a function call, a number, a variable expression or a string
769 1.196 rillig * literal. */
770 1.196 rillig static Token
771 1.196 rillig CondParser_LeafToken(CondParser *par, Boolean doEval)
772 1.196 rillig {
773 1.196 rillig Token t;
774 1.196 rillig char *arg = NULL;
775 1.196 rillig size_t arglen;
776 1.196 rillig const char *cp = par->p;
777 1.196 rillig const char *cp1;
778 1.196 rillig
779 1.196 rillig if (CondParser_Func(par, doEval, &t))
780 1.44 dsl return t;
781 1.44 dsl
782 1.47 dsl /* Push anything numeric through the compare expression */
783 1.122 rillig cp = par->p;
784 1.195 rillig if (ch_isdigit(cp[0]) || cp[0] == '-' || cp[0] == '+')
785 1.125 rillig return CondParser_Comparison(par, doEval);
786 1.47 dsl
787 1.44 dsl /*
788 1.48 dsl * Most likely we have a naked token to apply the default function to.
789 1.48 dsl * However ".if a == b" gets here when the "a" is unquoted and doesn't
790 1.58 dsl * start with a '$'. This surprises people.
791 1.48 dsl * If what follows the function argument is a '=' or '!' then the syntax
792 1.48 dsl * would be invalid if we did "defined(a)" - so instead treat as an
793 1.48 dsl * expression.
794 1.48 dsl */
795 1.127 rillig arglen = ParseFuncArg(&cp, doEval, NULL, &arg);
796 1.160 rillig cp1 = cp;
797 1.160 rillig cpp_skip_whitespace(&cp1);
798 1.48 dsl if (*cp1 == '=' || *cp1 == '!')
799 1.125 rillig return CondParser_Comparison(par, doEval);
800 1.122 rillig par->p = cp;
801 1.48 dsl
802 1.48 dsl /*
803 1.58 dsl * Evaluate the argument using the default function.
804 1.117 rillig * This path always treats .if as .ifdef. To get here, the character
805 1.58 dsl * after .if must have been taken literally, so the argument cannot
806 1.58 dsl * be empty - even if it contained a variable expansion.
807 1.44 dsl */
808 1.193 rillig t = ToToken(!doEval || If_Eval(par->if_info, arg, arglen));
809 1.73 christos 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.125 rillig CondParser_Token(CondParser *par, Boolean doEval)
816 1.1 cgd {
817 1.47 dsl Token t;
818 1.47 dsl
819 1.121 rillig t = par->curr;
820 1.59 dsl if (t != TOK_NONE) {
821 1.121 rillig par->curr = TOK_NONE;
822 1.47 dsl return t;
823 1.47 dsl }
824 1.47 dsl
825 1.177 rillig cpp_skip_hspace(&par->p);
826 1.47 dsl
827 1.122 rillig switch (par->p[0]) {
828 1.47 dsl
829 1.47 dsl case '(':
830 1.122 rillig par->p++;
831 1.59 dsl return TOK_LPAREN;
832 1.47 dsl
833 1.47 dsl case ')':
834 1.122 rillig par->p++;
835 1.59 dsl return TOK_RPAREN;
836 1.47 dsl
837 1.47 dsl case '|':
838 1.122 rillig par->p++;
839 1.197 rillig if (par->p[0] == '|')
840 1.122 rillig par->p++;
841 1.197 rillig else if (opts.lint) {
842 1.197 rillig Parse_Error(PARSE_FATAL, "Unknown operator '|'");
843 1.197 rillig par->printedError = TRUE;
844 1.197 rillig return TOK_ERROR;
845 1.47 dsl }
846 1.59 dsl return TOK_OR;
847 1.1 cgd
848 1.47 dsl case '&':
849 1.122 rillig par->p++;
850 1.197 rillig if (par->p[0] == '&')
851 1.122 rillig par->p++;
852 1.197 rillig else if (opts.lint) {
853 1.197 rillig Parse_Error(PARSE_FATAL, "Unknown operator '&'");
854 1.197 rillig par->printedError = TRUE;
855 1.197 rillig return TOK_ERROR;
856 1.1 cgd }
857 1.59 dsl return TOK_AND;
858 1.47 dsl
859 1.47 dsl case '!':
860 1.122 rillig par->p++;
861 1.59 dsl return TOK_NOT;
862 1.4 cgd
863 1.198 rillig case '#': /* XXX: see unit-tests/cond-token-plain.mk */
864 1.198 rillig case '\n': /* XXX: why should this end the condition? */
865 1.198 rillig /* Probably obsolete now, from 1993-03-21. */
866 1.47 dsl case '\0':
867 1.59 dsl return TOK_EOF;
868 1.47 dsl
869 1.47 dsl case '"':
870 1.47 dsl case '$':
871 1.125 rillig return CondParser_Comparison(par, doEval);
872 1.1 cgd
873 1.47 dsl default:
874 1.194 rillig return CondParser_LeafToken(par, doEval);
875 1.1 cgd }
876 1.1 cgd }
877 1.47 dsl
878 1.117 rillig /* Parse a single term in the expression. This consists of a terminal symbol
879 1.117 rillig * or TOK_NOT and a term (not including the binary operators):
880 1.117 rillig *
881 1.117 rillig * T -> defined(variable) | make(target) | exists(file) | symbol
882 1.117 rillig * T -> ! T | ( E )
883 1.1 cgd *
884 1.1 cgd * Results:
885 1.59 dsl * TOK_TRUE, TOK_FALSE or TOK_ERROR.
886 1.1 cgd */
887 1.1 cgd static Token
888 1.125 rillig CondParser_Term(CondParser *par, Boolean doEval)
889 1.1 cgd {
890 1.93 rillig Token t;
891 1.1 cgd
892 1.125 rillig t = CondParser_Token(par, doEval);
893 1.1 cgd
894 1.59 dsl if (t == TOK_EOF) {
895 1.1 cgd /*
896 1.1 cgd * If we reached the end of the expression, the expression
897 1.1 cgd * is malformed...
898 1.1 cgd */
899 1.59 dsl t = TOK_ERROR;
900 1.59 dsl } else if (t == TOK_LPAREN) {
901 1.1 cgd /*
902 1.1 cgd * T -> ( E )
903 1.1 cgd */
904 1.125 rillig t = CondParser_Expr(par, doEval);
905 1.59 dsl if (t != TOK_ERROR) {
906 1.125 rillig if (CondParser_Token(par, doEval) != TOK_RPAREN) {
907 1.59 dsl t = TOK_ERROR;
908 1.1 cgd }
909 1.1 cgd }
910 1.59 dsl } else if (t == TOK_NOT) {
911 1.125 rillig t = CondParser_Term(par, doEval);
912 1.59 dsl if (t == TOK_TRUE) {
913 1.59 dsl t = TOK_FALSE;
914 1.59 dsl } else if (t == TOK_FALSE) {
915 1.59 dsl t = TOK_TRUE;
916 1.1 cgd }
917 1.1 cgd }
918 1.77 rillig return t;
919 1.1 cgd }
920 1.90 rillig
921 1.117 rillig /* Parse a conjunctive factor (nice name, wot?)
922 1.117 rillig *
923 1.117 rillig * F -> T && F | T
924 1.1 cgd *
925 1.1 cgd * Results:
926 1.59 dsl * TOK_TRUE, TOK_FALSE or TOK_ERROR
927 1.1 cgd */
928 1.1 cgd static Token
929 1.125 rillig CondParser_Factor(CondParser *par, Boolean doEval)
930 1.1 cgd {
931 1.93 rillig Token l, o;
932 1.1 cgd
933 1.125 rillig l = CondParser_Term(par, doEval);
934 1.59 dsl if (l != TOK_ERROR) {
935 1.125 rillig o = CondParser_Token(par, doEval);
936 1.1 cgd
937 1.59 dsl if (o == TOK_AND) {
938 1.1 cgd /*
939 1.1 cgd * F -> T && F
940 1.1 cgd *
941 1.117 rillig * If T is TOK_FALSE, the whole thing will be TOK_FALSE, but we
942 1.117 rillig * have to parse the r.h.s. anyway (to throw it away).
943 1.117 rillig * If T is TOK_TRUE, the result is the r.h.s., be it a TOK_ERROR
944 1.117 rillig * or not.
945 1.1 cgd */
946 1.59 dsl if (l == TOK_TRUE) {
947 1.125 rillig l = CondParser_Factor(par, doEval);
948 1.1 cgd } else {
949 1.125 rillig (void)CondParser_Factor(par, FALSE);
950 1.1 cgd }
951 1.1 cgd } else {
952 1.1 cgd /*
953 1.1 cgd * F -> T
954 1.1 cgd */
955 1.121 rillig CondParser_PushBack(par, o);
956 1.1 cgd }
957 1.1 cgd }
958 1.77 rillig return l;
959 1.1 cgd }
960 1.90 rillig
961 1.117 rillig /* Main expression production.
962 1.117 rillig *
963 1.117 rillig * E -> F || E | F
964 1.1 cgd *
965 1.1 cgd * Results:
966 1.59 dsl * TOK_TRUE, TOK_FALSE or TOK_ERROR.
967 1.1 cgd */
968 1.1 cgd static Token
969 1.125 rillig CondParser_Expr(CondParser *par, Boolean doEval)
970 1.1 cgd {
971 1.93 rillig Token l, o;
972 1.1 cgd
973 1.125 rillig l = CondParser_Factor(par, doEval);
974 1.59 dsl if (l != TOK_ERROR) {
975 1.125 rillig o = CondParser_Token(par, doEval);
976 1.1 cgd
977 1.59 dsl if (o == TOK_OR) {
978 1.1 cgd /*
979 1.1 cgd * E -> F || E
980 1.1 cgd *
981 1.1 cgd * A similar thing occurs for ||, except that here we make sure
982 1.59 dsl * the l.h.s. is TOK_FALSE before we bother to evaluate the r.h.s.
983 1.59 dsl * Once again, if l is TOK_FALSE, the result is the r.h.s. and once
984 1.59 dsl * again if l is TOK_TRUE, we parse the r.h.s. to throw it away.
985 1.1 cgd */
986 1.59 dsl if (l == TOK_FALSE) {
987 1.125 rillig l = CondParser_Expr(par, doEval);
988 1.1 cgd } else {
989 1.125 rillig (void)CondParser_Expr(par, FALSE);
990 1.1 cgd }
991 1.1 cgd } else {
992 1.1 cgd /*
993 1.1 cgd * E -> F
994 1.1 cgd */
995 1.121 rillig CondParser_PushBack(par, o);
996 1.1 cgd }
997 1.1 cgd }
998 1.77 rillig return l;
999 1.1 cgd }
1000 1.10 christos
1001 1.89 rillig static CondEvalResult
1002 1.125 rillig CondParser_Eval(CondParser *par, Boolean *value)
1003 1.89 rillig {
1004 1.128 rillig Token res;
1005 1.128 rillig
1006 1.154 rillig DEBUG1(COND, "CondParser_Eval: %s\n", par->p);
1007 1.128 rillig
1008 1.128 rillig res = CondParser_Expr(par, TRUE);
1009 1.126 rillig if (res != TOK_FALSE && res != TOK_TRUE)
1010 1.137 rillig return COND_INVALID;
1011 1.89 rillig
1012 1.126 rillig if (CondParser_Token(par, TRUE /* XXX: Why TRUE? */) != TOK_EOF)
1013 1.137 rillig return COND_INVALID;
1014 1.89 rillig
1015 1.126 rillig *value = res == TOK_TRUE;
1016 1.126 rillig return COND_PARSE;
1017 1.89 rillig }
1018 1.89 rillig
1019 1.128 rillig /* Evaluate the condition, including any side effects from the variable
1020 1.128 rillig * expressions in the condition. The condition consists of &&, ||, !,
1021 1.128 rillig * function(arg), comparisons and parenthetical groupings thereof.
1022 1.10 christos *
1023 1.10 christos * Results:
1024 1.10 christos * COND_PARSE if the condition was valid grammatically
1025 1.153 rillig * COND_INVALID if not a valid conditional.
1026 1.10 christos *
1027 1.10 christos * (*value) is set to the boolean value of the condition
1028 1.10 christos */
1029 1.142 rillig static CondEvalResult
1030 1.142 rillig CondEvalExpression(const struct If *info, const char *cond, Boolean *value,
1031 1.143 rillig Boolean eprint, Boolean strictLHS)
1032 1.10 christos {
1033 1.121 rillig CondParser par;
1034 1.183 rillig CondEvalResult rval;
1035 1.10 christos
1036 1.68 sjg lhsStrict = strictLHS;
1037 1.68 sjg
1038 1.177 rillig cpp_skip_hspace(&cond);
1039 1.10 christos
1040 1.208 rillig par.if_info = info != NULL ? info : ifs + PLAIN_IF_INDEX;
1041 1.128 rillig par.p = cond;
1042 1.121 rillig par.curr = TOK_NONE;
1043 1.146 rillig par.printedError = FALSE;
1044 1.10 christos
1045 1.125 rillig rval = CondParser_Eval(&par, value);
1046 1.56 dsl
1047 1.146 rillig if (rval == COND_INVALID && eprint && !par.printedError)
1048 1.128 rillig Parse_Error(PARSE_FATAL, "Malformed conditional (%s)", cond);
1049 1.56 dsl
1050 1.56 dsl return rval;
1051 1.56 dsl }
1052 1.56 dsl
1053 1.206 rillig /* Evaluate a condition in a :? modifier, such as
1054 1.206 rillig * ${"${VAR}" == value:?yes:no}. */
1055 1.142 rillig CondEvalResult
1056 1.142 rillig Cond_EvalCondition(const char *cond, Boolean *out_value)
1057 1.142 rillig {
1058 1.143 rillig return CondEvalExpression(NULL, cond, out_value, FALSE, FALSE);
1059 1.142 rillig }
1060 1.90 rillig
1061 1.209 rillig /* Evaluate the conditional directive in the line, which is one of:
1062 1.207 rillig *
1063 1.206 rillig * .if <cond>
1064 1.206 rillig * .ifmake <cond>
1065 1.206 rillig * .ifnmake <cond>
1066 1.206 rillig * .ifdef <cond>
1067 1.206 rillig * .ifndef <cond>
1068 1.206 rillig * .elif <cond>
1069 1.206 rillig * .elifmake <cond>
1070 1.206 rillig * .elifnmake <cond>
1071 1.206 rillig * .elifdef <cond>
1072 1.206 rillig * .elifndef <cond>
1073 1.206 rillig * .else
1074 1.206 rillig * .endif
1075 1.207 rillig *
1076 1.207 rillig * In these directives, <cond> consists of &&, ||, !, function(arg),
1077 1.207 rillig * comparisons, expressions, bare words, numbers and strings, and
1078 1.207 rillig * parenthetical groupings thereof.
1079 1.1 cgd *
1080 1.108 rillig * Results:
1081 1.207 rillig * COND_PARSE to continue parsing the lines that follow the
1082 1.207 rillig * conditional (when <cond> evaluates to TRUE)
1083 1.108 rillig * COND_SKIP to skip the lines after the conditional
1084 1.207 rillig * (when <cond> evaluates to FALSE, or when a previous
1085 1.108 rillig * branch has already been taken)
1086 1.153 rillig * COND_INVALID if the conditional was not valid, either because of
1087 1.108 rillig * a syntax error or because some variable was undefined
1088 1.108 rillig * or because the condition could not be evaluated
1089 1.1 cgd */
1090 1.86 rillig CondEvalResult
1091 1.209 rillig Cond_EvalLine(const char *const line)
1092 1.1 cgd {
1093 1.206 rillig typedef enum IfState {
1094 1.207 rillig
1095 1.207 rillig /* The previous <cond> evaluated to TRUE. The lines following this
1096 1.207 rillig * condition are interpreted. */
1097 1.207 rillig IF_ACTIVE,
1098 1.207 rillig
1099 1.207 rillig /* The previous '.else' evaluated to TRUE. The lines following this
1100 1.207 rillig * condition are interpreted. The only difference to IF_ACTIVE is
1101 1.207 rillig * that no other '.else' may follow. */
1102 1.207 rillig ELSE_ACTIVE,
1103 1.207 rillig
1104 1.210 rillig /* All of the previous <cond> evaluated to FALSE. Still searching
1105 1.207 rillig * for an '.elif' or an 'else' that evaluates to TRUE. */
1106 1.207 rillig SEARCH_FOR_ELIF,
1107 1.207 rillig
1108 1.207 rillig /* One of the previous <cond> evaluated to TRUE. There was no '.else'
1109 1.207 rillig * yet. */
1110 1.207 rillig SKIP_TO_ELSE,
1111 1.207 rillig
1112 1.207 rillig /* One of the previous <cond> evaluated to TRUE, and '.else' was
1113 1.207 rillig * already seen. No other '.else' may follow. */
1114 1.207 rillig SKIP_TO_ENDIF
1115 1.207 rillig
1116 1.206 rillig } IfState;
1117 1.207 rillig
1118 1.206 rillig static enum IfState *cond_states = NULL;
1119 1.206 rillig static unsigned int cond_states_cap = 128;
1120 1.36 dsl
1121 1.36 dsl const struct If *ifp;
1122 1.93 rillig Boolean isElif;
1123 1.93 rillig Boolean value;
1124 1.206 rillig IfState state;
1125 1.209 rillig const char *p = line;
1126 1.1 cgd
1127 1.206 rillig if (cond_states == NULL) {
1128 1.206 rillig cond_states = bmake_malloc(cond_states_cap * sizeof *cond_states);
1129 1.206 rillig cond_states[0] = IF_ACTIVE;
1130 1.65 sjg }
1131 1.211 rillig
1132 1.209 rillig p++; /* skip the leading '.' */
1133 1.209 rillig cpp_skip_hspace(&p);
1134 1.1 cgd
1135 1.211 rillig /* Parse the name of the directive, such as 'if', 'elif', 'endif'. */
1136 1.209 rillig if (p[0] == 'e') {
1137 1.209 rillig if (p[1] != 'l') {
1138 1.211 rillig if (!is_token(p + 1, "ndif", 4)) {
1139 1.211 rillig /* Unknown directive. It might still be a transformation
1140 1.211 rillig * rule like '.elisp.scm', therefore no error message here. */
1141 1.36 dsl return COND_INVALID;
1142 1.206 rillig }
1143 1.211 rillig
1144 1.211 rillig /* It is an '.endif'. */
1145 1.211 rillig /* TODO: check for extraneous <cond> */
1146 1.211 rillig
1147 1.37 dsl if (cond_depth == cond_min_depth) {
1148 1.136 rillig Parse_Error(PARSE_FATAL, "if-less endif");
1149 1.36 dsl return COND_PARSE;
1150 1.36 dsl }
1151 1.211 rillig
1152 1.36 dsl /* Return state for previous conditional */
1153 1.36 dsl cond_depth--;
1154 1.206 rillig return cond_states[cond_depth] <= ELSE_ACTIVE
1155 1.93 rillig ? COND_PARSE : COND_SKIP;
1156 1.36 dsl }
1157 1.36 dsl
1158 1.36 dsl /* Quite likely this is 'else' or 'elif' */
1159 1.209 rillig p += 2;
1160 1.209 rillig if (is_token(p, "se", 2)) { /* It is an 'else'. */
1161 1.206 rillig
1162 1.206 rillig /* TODO: check for extraneous <cond> */
1163 1.206 rillig
1164 1.37 dsl if (cond_depth == cond_min_depth) {
1165 1.136 rillig Parse_Error(PARSE_FATAL, "if-less else");
1166 1.43 dsl return COND_PARSE;
1167 1.36 dsl }
1168 1.36 dsl
1169 1.206 rillig state = cond_states[cond_depth];
1170 1.36 dsl switch (state) {
1171 1.36 dsl case SEARCH_FOR_ELIF:
1172 1.36 dsl state = ELSE_ACTIVE;
1173 1.36 dsl break;
1174 1.36 dsl case ELSE_ACTIVE:
1175 1.36 dsl case SKIP_TO_ENDIF:
1176 1.36 dsl Parse_Error(PARSE_WARNING, "extra else");
1177 1.36 dsl /* FALLTHROUGH */
1178 1.36 dsl default:
1179 1.36 dsl case IF_ACTIVE:
1180 1.36 dsl case SKIP_TO_ELSE:
1181 1.36 dsl state = SKIP_TO_ENDIF;
1182 1.36 dsl break;
1183 1.1 cgd }
1184 1.206 rillig cond_states[cond_depth] = state;
1185 1.36 dsl return state <= ELSE_ACTIVE ? COND_PARSE : COND_SKIP;
1186 1.1 cgd }
1187 1.36 dsl /* Assume for now it is an elif */
1188 1.36 dsl isElif = TRUE;
1189 1.36 dsl } else
1190 1.36 dsl isElif = FALSE;
1191 1.36 dsl
1192 1.209 rillig if (p[0] != 'i' || p[1] != 'f') {
1193 1.211 rillig /* Unknown directive. It might still be a transformation rule like
1194 1.211 rillig * '.elisp.scm', therefore no error message here. */
1195 1.178 rillig return COND_INVALID; /* Not an ifxxx or elifxxx line */
1196 1.206 rillig }
1197 1.7 christos
1198 1.1 cgd /*
1199 1.1 cgd * Figure out what sort of conditional it is -- what its default
1200 1.1 cgd * function is, etc. -- by looking in the table of valid "ifs"
1201 1.1 cgd */
1202 1.209 rillig p += 2;
1203 1.93 rillig for (ifp = ifs;; ifp++) {
1204 1.206 rillig if (ifp->form == NULL) {
1205 1.206 rillig /* TODO: Add error message about unknown directive,
1206 1.206 rillig * since there is no other known directive that starts with 'el'
1207 1.206 rillig * or 'if'.
1208 1.206 rillig * Example: .elifx 123 */
1209 1.36 dsl return COND_INVALID;
1210 1.206 rillig }
1211 1.209 rillig if (is_token(p, ifp->form, ifp->formlen)) {
1212 1.209 rillig p += ifp->formlen;
1213 1.1 cgd break;
1214 1.1 cgd }
1215 1.1 cgd }
1216 1.1 cgd
1217 1.36 dsl /* Now we know what sort of 'if' it is... */
1218 1.36 dsl
1219 1.36 dsl if (isElif) {
1220 1.37 dsl if (cond_depth == cond_min_depth) {
1221 1.136 rillig Parse_Error(PARSE_FATAL, "if-less elif");
1222 1.43 dsl return COND_PARSE;
1223 1.36 dsl }
1224 1.206 rillig state = cond_states[cond_depth];
1225 1.43 dsl if (state == SKIP_TO_ENDIF || state == ELSE_ACTIVE) {
1226 1.36 dsl Parse_Error(PARSE_WARNING, "extra elif");
1227 1.206 rillig cond_states[cond_depth] = SKIP_TO_ENDIF;
1228 1.43 dsl return COND_SKIP;
1229 1.43 dsl }
1230 1.36 dsl if (state != SEARCH_FOR_ELIF) {
1231 1.36 dsl /* Either just finished the 'true' block, or already SKIP_TO_ELSE */
1232 1.206 rillig cond_states[cond_depth] = SKIP_TO_ELSE;
1233 1.36 dsl return COND_SKIP;
1234 1.1 cgd }
1235 1.1 cgd } else {
1236 1.43 dsl /* Normal .if */
1237 1.206 rillig if (cond_depth + 1 >= cond_states_cap) {
1238 1.65 sjg /*
1239 1.65 sjg * This is rare, but not impossible.
1240 1.65 sjg * In meta mode, dirdeps.mk (only runs at level 0)
1241 1.65 sjg * can need more than the default.
1242 1.65 sjg */
1243 1.206 rillig cond_states_cap += 32;
1244 1.206 rillig cond_states = bmake_realloc(cond_states,
1245 1.206 rillig cond_states_cap * sizeof *cond_states);
1246 1.1 cgd }
1247 1.206 rillig state = cond_states[cond_depth];
1248 1.36 dsl cond_depth++;
1249 1.36 dsl if (state > ELSE_ACTIVE) {
1250 1.36 dsl /* If we aren't parsing the data, treat as always false */
1251 1.206 rillig cond_states[cond_depth] = SKIP_TO_ELSE;
1252 1.36 dsl return COND_SKIP;
1253 1.32 christos }
1254 1.1 cgd }
1255 1.1 cgd
1256 1.109 rillig /* And evaluate the conditional expression */
1257 1.209 rillig if (CondEvalExpression(ifp, p, &value, TRUE, TRUE) == COND_INVALID) {
1258 1.43 dsl /* Syntax error in conditional, error message already output. */
1259 1.43 dsl /* Skip everything to matching .endif */
1260 1.206 rillig cond_states[cond_depth] = SKIP_TO_ELSE;
1261 1.43 dsl return COND_SKIP;
1262 1.36 dsl }
1263 1.36 dsl
1264 1.36 dsl if (!value) {
1265 1.206 rillig cond_states[cond_depth] = SEARCH_FOR_ELIF;
1266 1.36 dsl return COND_SKIP;
1267 1.36 dsl }
1268 1.206 rillig cond_states[cond_depth] = IF_ACTIVE;
1269 1.36 dsl return COND_PARSE;
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.162 rillig unsigned int open_conds = cond_depth - cond_min_depth;
1276 1.37 dsl
1277 1.37 dsl if (open_conds != 0 || saved_depth > cond_depth) {
1278 1.162 rillig Parse_Error(PARSE_FATAL, "%u open conditional%s", open_conds,
1279 1.37 dsl open_conds == 1 ? "" : "s");
1280 1.37 dsl cond_depth = cond_min_depth;
1281 1.1 cgd }
1282 1.37 dsl
1283 1.37 dsl 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.162 rillig unsigned int depth = cond_min_depth;
1290 1.37 dsl
1291 1.37 dsl cond_min_depth = cond_depth;
1292 1.37 dsl return depth;
1293 1.1 cgd }
1294