1 // SPDX-License-Identifier: GPL-2.0 2 // 3 // Copyright (C) 2018 Masahiro Yamada <[email protected]> 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 const struct function function_table[] = { 110 /* Name MIN MAX Function */ 111 }; 112 113 #define FUNCTION_MAX_ARGS 16 114 115 static char *function_expand(const char *name, int argc, char *argv[]) 116 { 117 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 */ 145 static 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; 152 153 tmp = xstrndup(str, len); 154 155 prev = p = tmp; 156 157 /* 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); 202 if (res) 203 goto free; 204 205 /* Last, try environment variable */ 206 if (new_argc == 0) { 207 res = env_expand(name); 208 if (res) 209 goto free; 210 } 211 212 res = xstrdup(""); 213 free: 214 for (i = 0; i < new_argc; i++) 215 free(new_argv[i]); 216 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 */ 234 static char *expand_dollar_with_args(const char **str, int argc, char *argv[]) 235 { 236 const char *p = *str; 237 const char *q; 238 int nest = 0; 239 240 /* 241 * In Kconfig, variable/function references always start with "$(". 242 * 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 268 return eval_clause(p, q - p, argc, argv); 269 } 270 271 char *expand_dollar(const char **str) 272 { 273 return expand_dollar_with_args(str, 0, NULL); 274 } 275 276 static char *__expand_string(const char **str, bool (*is_end)(char c), 277 int argc, char *argv[]) 278 { 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++; 293 expansion = expand_dollar_with_args(&p, argc, argv); 294 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 320 static bool is_end_of_str(char c) 321 { 322 return !c; 323 } 324 325 /* 326 * Expand variables and functions in the given string. Undefined variables 327 * expand to an empty string. 328 * The returned string must be freed when done. 329 */ 330 static 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 335 char *expand_string(const char *in) 336 { 337 return expand_string_with_args(in, 0, NULL); 338 } 339 340 static 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 */ 353 char *expand_one_token(const char **str) 354 { 355 return __expand_string(str, is_end_of_token, 0, NULL); 356 } 357