blob: f32a496626da0f5faa493c95a5922eef447ef6b8 [file] [log] [blame]
Masahiro Yamada104daea2018-05-28 18:21:40 +09001// SPDX-License-Identifier: GPL-2.0
2//
3// Copyright (C) 2018 Masahiro Yamada <yamada.masahiro@socionext.com>
4
5#include <stdarg.h>
6#include <stdbool.h>
7#include <stdio.h>
8#include <stdlib.h>
9#include <string.h>
10
11#include "list.h"
12
Masahiro Yamadae298f3b2018-05-28 18:21:45 +090013#define ARRAY_SIZE(arr) (sizeof(arr) / sizeof((arr)[0]))
14
15static char *expand_string_with_args(const char *in, int argc, char *argv[]);
16
Masahiro Yamada104daea2018-05-28 18:21:40 +090017static void __attribute__((noreturn)) pperror(const char *format, ...)
18{
19 va_list ap;
20
21 fprintf(stderr, "%s:%d: ", current_file->name, yylineno);
22 va_start(ap, format);
23 vfprintf(stderr, format, ap);
24 va_end(ap);
25 fprintf(stderr, "\n");
26
27 exit(1);
28}
29
30/*
31 * Environment variables
32 */
33static LIST_HEAD(env_list);
34
35struct env {
36 char *name;
37 char *value;
38 struct list_head node;
39};
40
41static void env_add(const char *name, const char *value)
42{
43 struct env *e;
44
45 e = xmalloc(sizeof(*e));
46 e->name = xstrdup(name);
47 e->value = xstrdup(value);
48
49 list_add_tail(&e->node, &env_list);
50}
51
52static void env_del(struct env *e)
53{
54 list_del(&e->node);
55 free(e->name);
56 free(e->value);
57 free(e);
58}
59
60/* The returned pointer must be freed when done */
61static char *env_expand(const char *name)
62{
63 struct env *e;
64 const char *value;
65
66 if (!*name)
67 return NULL;
68
69 list_for_each_entry(e, &env_list, node) {
70 if (!strcmp(name, e->name))
71 return xstrdup(e->value);
72 }
73
74 value = getenv(name);
75 if (!value)
76 return NULL;
77
78 /*
79 * We need to remember all referenced environment variables.
80 * They will be written out to include/config/auto.conf.cmd
81 */
82 env_add(name, value);
83
84 return xstrdup(value);
85}
86
87void env_write_dep(FILE *f, const char *autoconfig_name)
88{
89 struct env *e, *tmp;
90
91 list_for_each_entry_safe(e, tmp, &env_list, node) {
92 fprintf(f, "ifneq \"$(%s)\" \"%s\"\n", e->name, e->value);
93 fprintf(f, "%s: FORCE\n", autoconfig_name);
94 fprintf(f, "endif\n");
95 env_del(e);
96 }
97}
98
Masahiro Yamadae298f3b2018-05-28 18:21:45 +090099/*
100 * Built-in functions
101 */
102struct function {
103 const char *name;
104 unsigned int min_args;
105 unsigned int max_args;
106 char *(*func)(int argc, char *argv[]);
107};
108
109static const struct function function_table[] = {
110 /* Name MIN MAX Function */
111};
112
113#define FUNCTION_MAX_ARGS 16
114
115static char *function_expand(const char *name, int argc, char *argv[])
Masahiro Yamada104daea2018-05-28 18:21:40 +0900116{
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900117 const struct function *f;
118 int i;
119
120 for (i = 0; i < ARRAY_SIZE(function_table); i++) {
121 f = &function_table[i];
122 if (strcmp(f->name, name))
123 continue;
124
125 if (argc < f->min_args)
126 pperror("too few function arguments passed to '%s'",
127 name);
128
129 if (argc > f->max_args)
130 pperror("too many function arguments passed to '%s'",
131 name);
132
133 return f->func(argc, argv);
134 }
135
136 return NULL;
137}
138
139/*
140 * Evaluate a clause with arguments. argc/argv are arguments from the upper
141 * function call.
142 *
143 * Returned string must be freed when done
144 */
145static char *eval_clause(const char *str, size_t len, int argc, char *argv[])
146{
147 char *tmp, *name, *res, *prev, *p;
148 int new_argc = 0;
149 char *new_argv[FUNCTION_MAX_ARGS];
150 int nest = 0;
151 int i;
Masahiro Yamada104daea2018-05-28 18:21:40 +0900152
153 tmp = xstrndup(str, len);
154
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900155 prev = p = tmp;
Masahiro Yamada104daea2018-05-28 18:21:40 +0900156
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900157 /*
158 * Split into tokens
159 * The function name and arguments are separated by a comma.
160 * For example, if the function call is like this:
161 * $(foo,$(x),$(y))
162 *
163 * The input string for this helper should be:
164 * foo,$(x),$(y)
165 *
166 * and split into:
167 * new_argv[0] = 'foo'
168 * new_argv[1] = '$(x)'
169 * new_argv[2] = '$(y)'
170 */
171 while (*p) {
172 if (nest == 0 && *p == ',') {
173 *p = 0;
174 if (new_argc >= FUNCTION_MAX_ARGS)
175 pperror("too many function arguments");
176 new_argv[new_argc++] = prev;
177 prev = p + 1;
178 } else if (*p == '(') {
179 nest++;
180 } else if (*p == ')') {
181 nest--;
182 }
183
184 p++;
185 }
186 new_argv[new_argc++] = prev;
187
188 /*
189 * Shift arguments
190 * new_argv[0] represents a function name or a variable name. Put it
191 * into 'name', then shift the rest of the arguments. This simplifies
192 * 'const' handling.
193 */
194 name = expand_string_with_args(new_argv[0], argc, argv);
195 new_argc--;
196 for (i = 0; i < new_argc; i++)
197 new_argv[i] = expand_string_with_args(new_argv[i + 1],
198 argc, argv);
199
200 /* Look for built-in functions */
201 res = function_expand(name, new_argc, new_argv);
Masahiro Yamada104daea2018-05-28 18:21:40 +0900202 if (res)
203 goto free;
204
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900205 /* Last, try environment variable */
206 if (new_argc == 0) {
207 res = env_expand(name);
208 if (res)
209 goto free;
210 }
211
Masahiro Yamada104daea2018-05-28 18:21:40 +0900212 res = xstrdup("");
213free:
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900214 for (i = 0; i < new_argc; i++)
215 free(new_argv[i]);
Masahiro Yamada104daea2018-05-28 18:21:40 +0900216 free(name);
217 free(tmp);
218
219 return res;
220}
221
222/*
223 * Expand a string that follows '$'
224 *
225 * For example, if the input string is
226 * ($(FOO)$($(BAR)))$(BAZ)
227 * this helper evaluates
228 * $($(FOO)$($(BAR)))
229 * and returns a new string containing the expansion (note that the string is
230 * recursively expanded), also advancing 'str' to point to the next character
231 * after the corresponding closing parenthesis, in this case, *str will be
232 * $(BAR)
233 */
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900234static char *expand_dollar_with_args(const char **str, int argc, char *argv[])
Masahiro Yamada104daea2018-05-28 18:21:40 +0900235{
236 const char *p = *str;
237 const char *q;
238 int nest = 0;
239
240 /*
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900241 * In Kconfig, variable/function references always start with "$(".
Masahiro Yamada104daea2018-05-28 18:21:40 +0900242 * Neither single-letter variables as in $A nor curly braces as in ${CC}
243 * are supported. '$' not followed by '(' loses its special meaning.
244 */
245 if (*p != '(') {
246 *str = p;
247 return xstrdup("$");
248 }
249
250 p++;
251 q = p;
252 while (*q) {
253 if (*q == '(') {
254 nest++;
255 } else if (*q == ')') {
256 if (nest-- == 0)
257 break;
258 }
259 q++;
260 }
261
262 if (!*q)
263 pperror("unterminated reference to '%s': missing ')'", p);
264
265 /* Advance 'str' to after the expanded initial portion of the string */
266 *str = q + 1;
267
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900268 return eval_clause(p, q - p, argc, argv);
Masahiro Yamada104daea2018-05-28 18:21:40 +0900269}
270
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900271char *expand_dollar(const char **str)
272{
273 return expand_dollar_with_args(str, 0, NULL);
274}
275
276static char *__expand_string(const char **str, bool (*is_end)(char c),
277 int argc, char *argv[])
Masahiro Yamada104daea2018-05-28 18:21:40 +0900278{
279 const char *in, *p;
280 char *expansion, *out;
281 size_t in_len, out_len;
282
283 out = xmalloc(1);
284 *out = 0;
285 out_len = 1;
286
287 p = in = *str;
288
289 while (1) {
290 if (*p == '$') {
291 in_len = p - in;
292 p++;
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900293 expansion = expand_dollar_with_args(&p, argc, argv);
Masahiro Yamada104daea2018-05-28 18:21:40 +0900294 out_len += in_len + strlen(expansion);
295 out = xrealloc(out, out_len);
296 strncat(out, in, in_len);
297 strcat(out, expansion);
298 free(expansion);
299 in = p;
300 continue;
301 }
302
303 if (is_end(*p))
304 break;
305
306 p++;
307 }
308
309 in_len = p - in;
310 out_len += in_len;
311 out = xrealloc(out, out_len);
312 strncat(out, in, in_len);
313
314 /* Advance 'str' to the end character */
315 *str = p;
316
317 return out;
318}
319
320static bool is_end_of_str(char c)
321{
322 return !c;
323}
324
325/*
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900326 * Expand variables and functions in the given string. Undefined variables
Masahiro Yamada104daea2018-05-28 18:21:40 +0900327 * expand to an empty string.
328 * The returned string must be freed when done.
329 */
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900330static char *expand_string_with_args(const char *in, int argc, char *argv[])
331{
332 return __expand_string(&in, is_end_of_str, argc, argv);
333}
334
Masahiro Yamada104daea2018-05-28 18:21:40 +0900335char *expand_string(const char *in)
336{
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900337 return expand_string_with_args(in, 0, NULL);
Masahiro Yamada104daea2018-05-28 18:21:40 +0900338}
339
340static bool is_end_of_token(char c)
341{
342 /* Why are '.' and '/' valid characters for symbols? */
343 return !(isalnum(c) || c == '_' || c == '-' || c == '.' || c == '/');
344}
345
346/*
347 * Expand variables in a token. The parsing stops when a token separater
348 * (in most cases, it is a whitespace) is encountered. 'str' is updated to
349 * point to the next character.
350 *
351 * The returned string must be freed when done.
352 */
353char *expand_one_token(const char **str)
354{
Masahiro Yamadae298f3b2018-05-28 18:21:45 +0900355 return __expand_string(str, is_end_of_token, 0, NULL);
Masahiro Yamada104daea2018-05-28 18:21:40 +0900356}