xref: /openbmc/linux/scripts/kconfig/preprocess.c (revision a3b7039b)
1 // SPDX-License-Identifier: GPL-2.0
2 //
3 // Copyright (C) 2018 Masahiro Yamada <yamada.masahiro@socionext.com>
4 
5 #include <ctype.h>
6 #include <stdarg.h>
7 #include <stdbool.h>
8 #include <stdio.h>
9 #include <stdlib.h>
10 #include <string.h>
11 
12 #include "list.h"
13 #include "lkc.h"
14 
15 #define ARRAY_SIZE(arr)		(sizeof(arr) / sizeof((arr)[0]))
16 
17 static char *expand_string_with_args(const char *in, int argc, char *argv[]);
18 static char *expand_string(const char *in);
19 
pperror(const char * format,...)20 static void __attribute__((noreturn)) pperror(const char *format, ...)
21 {
22 	va_list ap;
23 
24 	fprintf(stderr, "%s:%d: ", current_file->name, yylineno);
25 	va_start(ap, format);
26 	vfprintf(stderr, format, ap);
27 	va_end(ap);
28 	fprintf(stderr, "\n");
29 
30 	exit(1);
31 }
32 
33 /*
34  * Environment variables
35  */
36 static LIST_HEAD(env_list);
37 
38 struct env {
39 	char *name;
40 	char *value;
41 	struct list_head node;
42 };
43 
env_add(const char * name,const char * value)44 static void env_add(const char *name, const char *value)
45 {
46 	struct env *e;
47 
48 	e = xmalloc(sizeof(*e));
49 	e->name = xstrdup(name);
50 	e->value = xstrdup(value);
51 
52 	list_add_tail(&e->node, &env_list);
53 }
54 
env_del(struct env * e)55 static void env_del(struct env *e)
56 {
57 	list_del(&e->node);
58 	free(e->name);
59 	free(e->value);
60 	free(e);
61 }
62 
63 /* The returned pointer must be freed when done */
env_expand(const char * name)64 static char *env_expand(const char *name)
65 {
66 	struct env *e;
67 	const char *value;
68 
69 	if (!*name)
70 		return NULL;
71 
72 	list_for_each_entry(e, &env_list, node) {
73 		if (!strcmp(name, e->name))
74 			return xstrdup(e->value);
75 	}
76 
77 	value = getenv(name);
78 	if (!value)
79 		return NULL;
80 
81 	/*
82 	 * We need to remember all referenced environment variables.
83 	 * They will be written out to include/config/auto.conf.cmd
84 	 */
85 	env_add(name, value);
86 
87 	return xstrdup(value);
88 }
89 
env_write_dep(FILE * f,const char * autoconfig_name)90 void env_write_dep(FILE *f, const char *autoconfig_name)
91 {
92 	struct env *e, *tmp;
93 
94 	list_for_each_entry_safe(e, tmp, &env_list, node) {
95 		fprintf(f, "ifneq \"$(%s)\" \"%s\"\n", e->name, e->value);
96 		fprintf(f, "%s: FORCE\n", autoconfig_name);
97 		fprintf(f, "endif\n");
98 		env_del(e);
99 	}
100 }
101 
102 /*
103  * Built-in functions
104  */
105 struct function {
106 	const char *name;
107 	unsigned int min_args;
108 	unsigned int max_args;
109 	char *(*func)(int argc, char *argv[]);
110 };
111 
do_error_if(int argc,char * argv[])112 static char *do_error_if(int argc, char *argv[])
113 {
114 	if (!strcmp(argv[0], "y"))
115 		pperror("%s", argv[1]);
116 
117 	return xstrdup("");
118 }
119 
do_filename(int argc,char * argv[])120 static char *do_filename(int argc, char *argv[])
121 {
122 	return xstrdup(current_file->name);
123 }
124 
do_info(int argc,char * argv[])125 static char *do_info(int argc, char *argv[])
126 {
127 	printf("%s\n", argv[0]);
128 
129 	return xstrdup("");
130 }
131 
do_lineno(int argc,char * argv[])132 static char *do_lineno(int argc, char *argv[])
133 {
134 	char buf[16];
135 
136 	sprintf(buf, "%d", yylineno);
137 
138 	return xstrdup(buf);
139 }
140 
do_shell(int argc,char * argv[])141 static char *do_shell(int argc, char *argv[])
142 {
143 	FILE *p;
144 	char buf[4096];
145 	char *cmd;
146 	size_t nread;
147 	int i;
148 
149 	cmd = argv[0];
150 
151 	p = popen(cmd, "r");
152 	if (!p) {
153 		perror(cmd);
154 		exit(1);
155 	}
156 
157 	nread = fread(buf, 1, sizeof(buf), p);
158 	if (nread == sizeof(buf))
159 		nread--;
160 
161 	/* remove trailing new lines */
162 	while (nread > 0 && buf[nread - 1] == '\n')
163 		nread--;
164 
165 	buf[nread] = 0;
166 
167 	/* replace a new line with a space */
168 	for (i = 0; i < nread; i++) {
169 		if (buf[i] == '\n')
170 			buf[i] = ' ';
171 	}
172 
173 	if (pclose(p) == -1) {
174 		perror(cmd);
175 		exit(1);
176 	}
177 
178 	return xstrdup(buf);
179 }
180 
do_warning_if(int argc,char * argv[])181 static char *do_warning_if(int argc, char *argv[])
182 {
183 	if (!strcmp(argv[0], "y"))
184 		fprintf(stderr, "%s:%d: %s\n",
185 			current_file->name, yylineno, argv[1]);
186 
187 	return xstrdup("");
188 }
189 
190 static const struct function function_table[] = {
191 	/* Name		MIN	MAX	Function */
192 	{ "error-if",	2,	2,	do_error_if },
193 	{ "filename",	0,	0,	do_filename },
194 	{ "info",	1,	1,	do_info },
195 	{ "lineno",	0,	0,	do_lineno },
196 	{ "shell",	1,	1,	do_shell },
197 	{ "warning-if",	2,	2,	do_warning_if },
198 };
199 
200 #define FUNCTION_MAX_ARGS		16
201 
function_expand(const char * name,int argc,char * argv[])202 static char *function_expand(const char *name, int argc, char *argv[])
203 {
204 	const struct function *f;
205 	int i;
206 
207 	for (i = 0; i < ARRAY_SIZE(function_table); i++) {
208 		f = &function_table[i];
209 		if (strcmp(f->name, name))
210 			continue;
211 
212 		if (argc < f->min_args)
213 			pperror("too few function arguments passed to '%s'",
214 				name);
215 
216 		if (argc > f->max_args)
217 			pperror("too many function arguments passed to '%s'",
218 				name);
219 
220 		return f->func(argc, argv);
221 	}
222 
223 	return NULL;
224 }
225 
226 /*
227  * Variables (and user-defined functions)
228  */
229 static LIST_HEAD(variable_list);
230 
231 struct variable {
232 	char *name;
233 	char *value;
234 	enum variable_flavor flavor;
235 	int exp_count;
236 	struct list_head node;
237 };
238 
variable_lookup(const char * name)239 static struct variable *variable_lookup(const char *name)
240 {
241 	struct variable *v;
242 
243 	list_for_each_entry(v, &variable_list, node) {
244 		if (!strcmp(name, v->name))
245 			return v;
246 	}
247 
248 	return NULL;
249 }
250 
variable_expand(const char * name,int argc,char * argv[])251 static char *variable_expand(const char *name, int argc, char *argv[])
252 {
253 	struct variable *v;
254 	char *res;
255 
256 	v = variable_lookup(name);
257 	if (!v)
258 		return NULL;
259 
260 	if (argc == 0 && v->exp_count)
261 		pperror("Recursive variable '%s' references itself (eventually)",
262 			name);
263 
264 	if (v->exp_count > 1000)
265 		pperror("Too deep recursive expansion");
266 
267 	v->exp_count++;
268 
269 	if (v->flavor == VAR_RECURSIVE)
270 		res = expand_string_with_args(v->value, argc, argv);
271 	else
272 		res = xstrdup(v->value);
273 
274 	v->exp_count--;
275 
276 	return res;
277 }
278 
variable_add(const char * name,const char * value,enum variable_flavor flavor)279 void variable_add(const char *name, const char *value,
280 		  enum variable_flavor flavor)
281 {
282 	struct variable *v;
283 	char *new_value;
284 	bool append = false;
285 
286 	v = variable_lookup(name);
287 	if (v) {
288 		/* For defined variables, += inherits the existing flavor */
289 		if (flavor == VAR_APPEND) {
290 			flavor = v->flavor;
291 			append = true;
292 		} else {
293 			free(v->value);
294 		}
295 	} else {
296 		/* For undefined variables, += assumes the recursive flavor */
297 		if (flavor == VAR_APPEND)
298 			flavor = VAR_RECURSIVE;
299 
300 		v = xmalloc(sizeof(*v));
301 		v->name = xstrdup(name);
302 		v->exp_count = 0;
303 		list_add_tail(&v->node, &variable_list);
304 	}
305 
306 	v->flavor = flavor;
307 
308 	if (flavor == VAR_SIMPLE)
309 		new_value = expand_string(value);
310 	else
311 		new_value = xstrdup(value);
312 
313 	if (append) {
314 		v->value = xrealloc(v->value,
315 				    strlen(v->value) + strlen(new_value) + 2);
316 		strcat(v->value, " ");
317 		strcat(v->value, new_value);
318 		free(new_value);
319 	} else {
320 		v->value = new_value;
321 	}
322 }
323 
variable_del(struct variable * v)324 static void variable_del(struct variable *v)
325 {
326 	list_del(&v->node);
327 	free(v->name);
328 	free(v->value);
329 	free(v);
330 }
331 
variable_all_del(void)332 void variable_all_del(void)
333 {
334 	struct variable *v, *tmp;
335 
336 	list_for_each_entry_safe(v, tmp, &variable_list, node)
337 		variable_del(v);
338 }
339 
340 /*
341  * Evaluate a clause with arguments.  argc/argv are arguments from the upper
342  * function call.
343  *
344  * Returned string must be freed when done
345  */
eval_clause(const char * str,size_t len,int argc,char * argv[])346 static char *eval_clause(const char *str, size_t len, int argc, char *argv[])
347 {
348 	char *tmp, *name, *res, *endptr, *prev, *p;
349 	int new_argc = 0;
350 	char *new_argv[FUNCTION_MAX_ARGS];
351 	int nest = 0;
352 	int i;
353 	unsigned long n;
354 
355 	tmp = xstrndup(str, len);
356 
357 	/*
358 	 * If variable name is '1', '2', etc.  It is generally an argument
359 	 * from a user-function call (i.e. local-scope variable).  If not
360 	 * available, then look-up global-scope variables.
361 	 */
362 	n = strtoul(tmp, &endptr, 10);
363 	if (!*endptr && n > 0 && n <= argc) {
364 		res = xstrdup(argv[n - 1]);
365 		goto free_tmp;
366 	}
367 
368 	prev = p = tmp;
369 
370 	/*
371 	 * Split into tokens
372 	 * The function name and arguments are separated by a comma.
373 	 * For example, if the function call is like this:
374 	 *   $(foo,$(x),$(y))
375 	 *
376 	 * The input string for this helper should be:
377 	 *   foo,$(x),$(y)
378 	 *
379 	 * and split into:
380 	 *   new_argv[0] = 'foo'
381 	 *   new_argv[1] = '$(x)'
382 	 *   new_argv[2] = '$(y)'
383 	 */
384 	while (*p) {
385 		if (nest == 0 && *p == ',') {
386 			*p = 0;
387 			if (new_argc >= FUNCTION_MAX_ARGS)
388 				pperror("too many function arguments");
389 			new_argv[new_argc++] = prev;
390 			prev = p + 1;
391 		} else if (*p == '(') {
392 			nest++;
393 		} else if (*p == ')') {
394 			nest--;
395 		}
396 
397 		p++;
398 	}
399 
400 	if (new_argc >= FUNCTION_MAX_ARGS)
401 		pperror("too many function arguments");
402 	new_argv[new_argc++] = prev;
403 
404 	/*
405 	 * Shift arguments
406 	 * new_argv[0] represents a function name or a variable name.  Put it
407 	 * into 'name', then shift the rest of the arguments.  This simplifies
408 	 * 'const' handling.
409 	 */
410 	name = expand_string_with_args(new_argv[0], argc, argv);
411 	new_argc--;
412 	for (i = 0; i < new_argc; i++)
413 		new_argv[i] = expand_string_with_args(new_argv[i + 1],
414 						      argc, argv);
415 
416 	/* Search for variables */
417 	res = variable_expand(name, new_argc, new_argv);
418 	if (res)
419 		goto free;
420 
421 	/* Look for built-in functions */
422 	res = function_expand(name, new_argc, new_argv);
423 	if (res)
424 		goto free;
425 
426 	/* Last, try environment variable */
427 	if (new_argc == 0) {
428 		res = env_expand(name);
429 		if (res)
430 			goto free;
431 	}
432 
433 	res = xstrdup("");
434 free:
435 	for (i = 0; i < new_argc; i++)
436 		free(new_argv[i]);
437 	free(name);
438 free_tmp:
439 	free(tmp);
440 
441 	return res;
442 }
443 
444 /*
445  * Expand a string that follows '$'
446  *
447  * For example, if the input string is
448  *     ($(FOO)$($(BAR)))$(BAZ)
449  * this helper evaluates
450  *     $($(FOO)$($(BAR)))
451  * and returns a new string containing the expansion (note that the string is
452  * recursively expanded), also advancing 'str' to point to the next character
453  * after the corresponding closing parenthesis, in this case, *str will be
454  *     $(BAR)
455  */
expand_dollar_with_args(const char ** str,int argc,char * argv[])456 static char *expand_dollar_with_args(const char **str, int argc, char *argv[])
457 {
458 	const char *p = *str;
459 	const char *q;
460 	int nest = 0;
461 
462 	/*
463 	 * In Kconfig, variable/function references always start with "$(".
464 	 * Neither single-letter variables as in $A nor curly braces as in ${CC}
465 	 * are supported.  '$' not followed by '(' loses its special meaning.
466 	 */
467 	if (*p != '(') {
468 		*str = p;
469 		return xstrdup("$");
470 	}
471 
472 	p++;
473 	q = p;
474 	while (*q) {
475 		if (*q == '(') {
476 			nest++;
477 		} else if (*q == ')') {
478 			if (nest-- == 0)
479 				break;
480 		}
481 		q++;
482 	}
483 
484 	if (!*q)
485 		pperror("unterminated reference to '%s': missing ')'", p);
486 
487 	/* Advance 'str' to after the expanded initial portion of the string */
488 	*str = q + 1;
489 
490 	return eval_clause(p, q - p, argc, argv);
491 }
492 
expand_dollar(const char ** str)493 char *expand_dollar(const char **str)
494 {
495 	return expand_dollar_with_args(str, 0, NULL);
496 }
497 
__expand_string(const char ** str,bool (* is_end)(char c),int argc,char * argv[])498 static char *__expand_string(const char **str, bool (*is_end)(char c),
499 			     int argc, char *argv[])
500 {
501 	const char *in, *p;
502 	char *expansion, *out;
503 	size_t in_len, out_len;
504 
505 	out = xmalloc(1);
506 	*out = 0;
507 	out_len = 1;
508 
509 	p = in = *str;
510 
511 	while (1) {
512 		if (*p == '$') {
513 			in_len = p - in;
514 			p++;
515 			expansion = expand_dollar_with_args(&p, argc, argv);
516 			out_len += in_len + strlen(expansion);
517 			out = xrealloc(out, out_len);
518 			strncat(out, in, in_len);
519 			strcat(out, expansion);
520 			free(expansion);
521 			in = p;
522 			continue;
523 		}
524 
525 		if (is_end(*p))
526 			break;
527 
528 		p++;
529 	}
530 
531 	in_len = p - in;
532 	out_len += in_len;
533 	out = xrealloc(out, out_len);
534 	strncat(out, in, in_len);
535 
536 	/* Advance 'str' to the end character */
537 	*str = p;
538 
539 	return out;
540 }
541 
is_end_of_str(char c)542 static bool is_end_of_str(char c)
543 {
544 	return !c;
545 }
546 
547 /*
548  * Expand variables and functions in the given string.  Undefined variables
549  * expand to an empty string.
550  * The returned string must be freed when done.
551  */
expand_string_with_args(const char * in,int argc,char * argv[])552 static char *expand_string_with_args(const char *in, int argc, char *argv[])
553 {
554 	return __expand_string(&in, is_end_of_str, argc, argv);
555 }
556 
expand_string(const char * in)557 static char *expand_string(const char *in)
558 {
559 	return expand_string_with_args(in, 0, NULL);
560 }
561 
is_end_of_token(char c)562 static bool is_end_of_token(char c)
563 {
564 	return !(isalnum(c) || c == '_' || c == '-');
565 }
566 
567 /*
568  * Expand variables in a token.  The parsing stops when a token separater
569  * (in most cases, it is a whitespace) is encountered.  'str' is updated to
570  * point to the next character.
571  *
572  * The returned string must be freed when done.
573  */
expand_one_token(const char ** str)574 char *expand_one_token(const char **str)
575 {
576 	return __expand_string(str, is_end_of_token, 0, NULL);
577 }
578