~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/scripts/kconfig/preprocess.c

Version: ~ [ linux-4.18-rc5 ] ~ [ linux-4.17.6 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.55 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.112 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.140 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.115 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.57 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.27.62 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

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

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp