• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3  * Released under the terms of the GNU GPL v2.0.
4  */
5 
6 #include <ctype.h>
7 #include <stdlib.h>
8 #include <string.h>
9 #include <regex.h>
10 #include <sys/utsname.h>
11 
12 #include "lkc.h"
13 
14 struct symbol symbol_yes = {
15 	.name = "y",
16 	.curr = { "y", yes },
17 	.flags = SYMBOL_CONST|SYMBOL_VALID,
18 }, symbol_mod = {
19 	.name = "m",
20 	.curr = { "m", mod },
21 	.flags = SYMBOL_CONST|SYMBOL_VALID,
22 }, symbol_no = {
23 	.name = "n",
24 	.curr = { "n", no },
25 	.flags = SYMBOL_CONST|SYMBOL_VALID,
26 }, symbol_empty = {
27 	.name = "",
28 	.curr = { "", no },
29 	.flags = SYMBOL_VALID,
30 };
31 
32 struct symbol *sym_defconfig_list;
33 struct symbol *modules_sym;
34 tristate modules_val;
35 
36 struct expr *sym_env_list;
37 
sym_add_default(struct symbol * sym,const char * def)38 static void sym_add_default(struct symbol *sym, const char *def)
39 {
40 	struct property *prop = prop_alloc(P_DEFAULT, sym);
41 
42 	prop->expr = expr_alloc_symbol(sym_lookup(def, SYMBOL_CONST));
43 }
44 
sym_init(void)45 void sym_init(void)
46 {
47 	struct symbol *sym;
48 	struct utsname uts;
49 	static bool inited = false;
50 
51 	if (inited)
52 		return;
53 	inited = true;
54 
55 	uname(&uts);
56 
57 	sym = sym_lookup("UNAME_RELEASE", 0);
58 	sym->type = S_STRING;
59 	sym->flags |= SYMBOL_AUTO;
60 	sym_add_default(sym, uts.release);
61 }
62 
sym_get_type(struct symbol * sym)63 enum symbol_type sym_get_type(struct symbol *sym)
64 {
65 	enum symbol_type type = sym->type;
66 
67 	if (type == S_TRISTATE) {
68 		if (sym_is_choice_value(sym) && sym->visible == yes)
69 			type = S_BOOLEAN;
70 		else if (modules_val == no)
71 			type = S_BOOLEAN;
72 	}
73 	return type;
74 }
75 
sym_type_name(enum symbol_type type)76 const char *sym_type_name(enum symbol_type type)
77 {
78 	switch (type) {
79 	case S_BOOLEAN:
80 		return "boolean";
81 	case S_TRISTATE:
82 		return "tristate";
83 	case S_INT:
84 		return "integer";
85 	case S_HEX:
86 		return "hex";
87 	case S_STRING:
88 		return "string";
89 	case S_UNKNOWN:
90 		return "unknown";
91 	case S_OTHER:
92 		break;
93 	}
94 	return "???";
95 }
96 
sym_get_choice_prop(struct symbol * sym)97 struct property *sym_get_choice_prop(struct symbol *sym)
98 {
99 	struct property *prop;
100 
101 	for_all_choices(sym, prop)
102 		return prop;
103 	return NULL;
104 }
105 
sym_get_env_prop(struct symbol * sym)106 struct property *sym_get_env_prop(struct symbol *sym)
107 {
108 	struct property *prop;
109 
110 	for_all_properties(sym, prop, P_ENV)
111 		return prop;
112 	return NULL;
113 }
114 
sym_get_default_prop(struct symbol * sym)115 static struct property *sym_get_default_prop(struct symbol *sym)
116 {
117 	struct property *prop;
118 
119 	for_all_defaults(sym, prop) {
120 		prop->visible.tri = expr_calc_value(prop->visible.expr);
121 		if (prop->visible.tri != no)
122 			return prop;
123 	}
124 	return NULL;
125 }
126 
sym_get_range_prop(struct symbol * sym)127 static struct property *sym_get_range_prop(struct symbol *sym)
128 {
129 	struct property *prop;
130 
131 	for_all_properties(sym, prop, P_RANGE) {
132 		prop->visible.tri = expr_calc_value(prop->visible.expr);
133 		if (prop->visible.tri != no)
134 			return prop;
135 	}
136 	return NULL;
137 }
138 
sym_get_range_val(struct symbol * sym,int base)139 static long long sym_get_range_val(struct symbol *sym, int base)
140 {
141 	sym_calc_value(sym);
142 	switch (sym->type) {
143 	case S_INT:
144 		base = 10;
145 		break;
146 	case S_HEX:
147 		base = 16;
148 		break;
149 	default:
150 		break;
151 	}
152 	return strtoll(sym->curr.val, NULL, base);
153 }
154 
sym_validate_range(struct symbol * sym)155 static void sym_validate_range(struct symbol *sym)
156 {
157 	struct property *prop;
158 	int base;
159 	long long val, val2;
160 	char str[64];
161 
162 	switch (sym->type) {
163 	case S_INT:
164 		base = 10;
165 		break;
166 	case S_HEX:
167 		base = 16;
168 		break;
169 	default:
170 		return;
171 	}
172 	prop = sym_get_range_prop(sym);
173 	if (!prop)
174 		return;
175 	val = strtoll(sym->curr.val, NULL, base);
176 	val2 = sym_get_range_val(prop->expr->left.sym, base);
177 	if (val >= val2) {
178 		val2 = sym_get_range_val(prop->expr->right.sym, base);
179 		if (val <= val2)
180 			return;
181 	}
182 	if (sym->type == S_INT)
183 		sprintf(str, "%lld", val2);
184 	else
185 		sprintf(str, "0x%llx", val2);
186 	sym->curr.val = strdup(str);
187 }
188 
sym_set_changed(struct symbol * sym)189 static void sym_set_changed(struct symbol *sym)
190 {
191 	struct property *prop;
192 
193 	sym->flags |= SYMBOL_CHANGED;
194 	for (prop = sym->prop; prop; prop = prop->next) {
195 		if (prop->menu)
196 			prop->menu->flags |= MENU_CHANGED;
197 	}
198 }
199 
sym_set_all_changed(void)200 static void sym_set_all_changed(void)
201 {
202 	struct symbol *sym;
203 	int i;
204 
205 	for_all_symbols(i, sym)
206 		sym_set_changed(sym);
207 }
208 
sym_calc_visibility(struct symbol * sym)209 static void sym_calc_visibility(struct symbol *sym)
210 {
211 	struct property *prop;
212 	tristate tri;
213 
214 	/* any prompt visible? */
215 	tri = no;
216 	for_all_prompts(sym, prop) {
217 		prop->visible.tri = expr_calc_value(prop->visible.expr);
218 		tri = EXPR_OR(tri, prop->visible.tri);
219 	}
220 	if (tri == mod && (sym->type != S_TRISTATE || modules_val == no))
221 		tri = yes;
222 	if (sym->visible != tri) {
223 		sym->visible = tri;
224 		sym_set_changed(sym);
225 	}
226 	if (sym_is_choice_value(sym))
227 		return;
228 	/* defaulting to "yes" if no explicit "depends on" are given */
229 	tri = yes;
230 	if (sym->dir_dep.expr)
231 		tri = expr_calc_value(sym->dir_dep.expr);
232 	if (tri == mod)
233 		tri = yes;
234 	if (sym->dir_dep.tri != tri) {
235 		sym->dir_dep.tri = tri;
236 		sym_set_changed(sym);
237 	}
238 	tri = no;
239 	if (sym->rev_dep.expr)
240 		tri = expr_calc_value(sym->rev_dep.expr);
241 	if (tri == mod && sym_get_type(sym) == S_BOOLEAN)
242 		tri = yes;
243 	if (sym->rev_dep.tri != tri) {
244 		sym->rev_dep.tri = tri;
245 		sym_set_changed(sym);
246 	}
247 }
248 
249 /*
250  * Find the default symbol for a choice.
251  * First try the default values for the choice symbol
252  * Next locate the first visible choice value
253  * Return NULL if none was found
254  */
sym_choice_default(struct symbol * sym)255 struct symbol *sym_choice_default(struct symbol *sym)
256 {
257 	struct symbol *def_sym;
258 	struct property *prop;
259 	struct expr *e;
260 
261 	/* any of the defaults visible? */
262 	for_all_defaults(sym, prop) {
263 		prop->visible.tri = expr_calc_value(prop->visible.expr);
264 		if (prop->visible.tri == no)
265 			continue;
266 		def_sym = prop_get_symbol(prop);
267 		if (def_sym->visible != no)
268 			return def_sym;
269 	}
270 
271 	/* just get the first visible value */
272 	prop = sym_get_choice_prop(sym);
273 	expr_list_for_each_sym(prop->expr, e, def_sym)
274 		if (def_sym->visible != no)
275 			return def_sym;
276 
277 	/* failed to locate any defaults */
278 	return NULL;
279 }
280 
sym_calc_choice(struct symbol * sym)281 static struct symbol *sym_calc_choice(struct symbol *sym)
282 {
283 	struct symbol *def_sym;
284 	struct property *prop;
285 	struct expr *e;
286 	int flags;
287 
288 	/* first calculate all choice values' visibilities */
289 	flags = sym->flags;
290 	prop = sym_get_choice_prop(sym);
291 	expr_list_for_each_sym(prop->expr, e, def_sym) {
292 		sym_calc_visibility(def_sym);
293 		if (def_sym->visible != no)
294 			flags &= def_sym->flags;
295 	}
296 
297 	sym->flags &= flags | ~SYMBOL_DEF_USER;
298 
299 	/* is the user choice visible? */
300 	def_sym = sym->def[S_DEF_USER].val;
301 	if (def_sym && def_sym->visible != no)
302 		return def_sym;
303 
304 	def_sym = sym_choice_default(sym);
305 
306 	if (def_sym == NULL)
307 		/* no choice? reset tristate value */
308 		sym->curr.tri = no;
309 
310 	return def_sym;
311 }
312 
sym_calc_value(struct symbol * sym)313 void sym_calc_value(struct symbol *sym)
314 {
315 	struct symbol_value newval, oldval;
316 	struct property *prop;
317 	struct expr *e;
318 
319 	if (!sym)
320 		return;
321 
322 	if (sym->flags & SYMBOL_VALID)
323 		return;
324 
325 	if (sym_is_choice_value(sym) &&
326 	    sym->flags & SYMBOL_NEED_SET_CHOICE_VALUES) {
327 		sym->flags &= ~SYMBOL_NEED_SET_CHOICE_VALUES;
328 		prop = sym_get_choice_prop(sym);
329 		sym_calc_value(prop_get_symbol(prop));
330 	}
331 
332 	sym->flags |= SYMBOL_VALID;
333 
334 	oldval = sym->curr;
335 
336 	switch (sym->type) {
337 	case S_INT:
338 	case S_HEX:
339 	case S_STRING:
340 		newval = symbol_empty.curr;
341 		break;
342 	case S_BOOLEAN:
343 	case S_TRISTATE:
344 		newval = symbol_no.curr;
345 		break;
346 	default:
347 		sym->curr.val = sym->name;
348 		sym->curr.tri = no;
349 		return;
350 	}
351 	if (!sym_is_choice_value(sym))
352 		sym->flags &= ~SYMBOL_WRITE;
353 
354 	sym_calc_visibility(sym);
355 
356 	/* set default if recursively called */
357 	sym->curr = newval;
358 
359 	switch (sym_get_type(sym)) {
360 	case S_BOOLEAN:
361 	case S_TRISTATE:
362 		if (sym_is_choice_value(sym) && sym->visible == yes) {
363 			prop = sym_get_choice_prop(sym);
364 			newval.tri = (prop_get_symbol(prop)->curr.val == sym) ? yes : no;
365 		} else {
366 			if (sym->visible != no) {
367 				/* if the symbol is visible use the user value
368 				 * if available, otherwise try the default value
369 				 */
370 				sym->flags |= SYMBOL_WRITE;
371 				if (sym_has_value(sym)) {
372 					newval.tri = EXPR_AND(sym->def[S_DEF_USER].tri,
373 							      sym->visible);
374 					goto calc_newval;
375 				}
376 			}
377 			if (sym->rev_dep.tri != no)
378 				sym->flags |= SYMBOL_WRITE;
379 			if (!sym_is_choice(sym)) {
380 				prop = sym_get_default_prop(sym);
381 				if (prop) {
382 					sym->flags |= SYMBOL_WRITE;
383 					newval.tri = EXPR_AND(expr_calc_value(prop->expr),
384 							      prop->visible.tri);
385 				}
386 			}
387 		calc_newval:
388 			if (sym->dir_dep.tri == no && sym->rev_dep.tri != no) {
389 				struct expr *e;
390 				e = expr_simplify_unmet_dep(sym->rev_dep.expr,
391 				    sym->dir_dep.expr);
392 				fprintf(stderr, "warning: (");
393 				expr_fprint(e, stderr);
394 				fprintf(stderr, ") selects %s which has unmet direct dependencies (",
395 					sym->name);
396 				expr_fprint(sym->dir_dep.expr, stderr);
397 				fprintf(stderr, ")\n");
398 				expr_free(e);
399 			}
400 			newval.tri = EXPR_OR(newval.tri, sym->rev_dep.tri);
401 		}
402 		if (newval.tri == mod && sym_get_type(sym) == S_BOOLEAN)
403 			newval.tri = yes;
404 		break;
405 	case S_STRING:
406 	case S_HEX:
407 	case S_INT:
408 		if (sym->visible != no) {
409 			sym->flags |= SYMBOL_WRITE;
410 			if (sym_has_value(sym)) {
411 				newval.val = sym->def[S_DEF_USER].val;
412 				break;
413 			}
414 		}
415 		prop = sym_get_default_prop(sym);
416 		if (prop) {
417 			struct symbol *ds = prop_get_symbol(prop);
418 			if (ds) {
419 				sym->flags |= SYMBOL_WRITE;
420 				sym_calc_value(ds);
421 				newval.val = ds->curr.val;
422 			}
423 		}
424 		break;
425 	default:
426 		;
427 	}
428 
429 	sym->curr = newval;
430 	if (sym_is_choice(sym) && newval.tri == yes)
431 		sym->curr.val = sym_calc_choice(sym);
432 	sym_validate_range(sym);
433 
434 	if (memcmp(&oldval, &sym->curr, sizeof(oldval))) {
435 		sym_set_changed(sym);
436 		if (modules_sym == sym) {
437 			sym_set_all_changed();
438 			modules_val = modules_sym->curr.tri;
439 		}
440 	}
441 
442 	if (sym_is_choice(sym)) {
443 		struct symbol *choice_sym;
444 
445 		prop = sym_get_choice_prop(sym);
446 		expr_list_for_each_sym(prop->expr, e, choice_sym) {
447 			if ((sym->flags & SYMBOL_WRITE) &&
448 			    choice_sym->visible != no)
449 				choice_sym->flags |= SYMBOL_WRITE;
450 			if (sym->flags & SYMBOL_CHANGED)
451 				sym_set_changed(choice_sym);
452 		}
453 	}
454 
455 	if (sym->flags & SYMBOL_AUTO)
456 		sym->flags &= ~SYMBOL_WRITE;
457 
458 	if (sym->flags & SYMBOL_NEED_SET_CHOICE_VALUES)
459 		set_all_choice_values(sym);
460 }
461 
sym_clear_all_valid(void)462 void sym_clear_all_valid(void)
463 {
464 	struct symbol *sym;
465 	int i;
466 
467 	for_all_symbols(i, sym)
468 		sym->flags &= ~SYMBOL_VALID;
469 	sym_add_change_count(1);
470 	sym_calc_value(modules_sym);
471 }
472 
sym_tristate_within_range(struct symbol * sym,tristate val)473 bool sym_tristate_within_range(struct symbol *sym, tristate val)
474 {
475 	int type = sym_get_type(sym);
476 
477 	if (sym->visible == no)
478 		return false;
479 
480 	if (type != S_BOOLEAN && type != S_TRISTATE)
481 		return false;
482 
483 	if (type == S_BOOLEAN && val == mod)
484 		return false;
485 	if (sym->visible <= sym->rev_dep.tri)
486 		return false;
487 	if (sym_is_choice_value(sym) && sym->visible == yes)
488 		return val == yes;
489 	return val >= sym->rev_dep.tri && val <= sym->visible;
490 }
491 
sym_set_tristate_value(struct symbol * sym,tristate val)492 bool sym_set_tristate_value(struct symbol *sym, tristate val)
493 {
494 	tristate oldval = sym_get_tristate_value(sym);
495 
496 	if (oldval != val && !sym_tristate_within_range(sym, val))
497 		return false;
498 
499 	if (!(sym->flags & SYMBOL_DEF_USER)) {
500 		sym->flags |= SYMBOL_DEF_USER;
501 		sym_set_changed(sym);
502 	}
503 	/*
504 	 * setting a choice value also resets the new flag of the choice
505 	 * symbol and all other choice values.
506 	 */
507 	if (sym_is_choice_value(sym) && val == yes) {
508 		struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
509 		struct property *prop;
510 		struct expr *e;
511 
512 		cs->def[S_DEF_USER].val = sym;
513 		cs->flags |= SYMBOL_DEF_USER;
514 		prop = sym_get_choice_prop(cs);
515 		for (e = prop->expr; e; e = e->left.expr) {
516 			if (e->right.sym->visible != no)
517 				e->right.sym->flags |= SYMBOL_DEF_USER;
518 		}
519 	}
520 
521 	sym->def[S_DEF_USER].tri = val;
522 	if (oldval != val)
523 		sym_clear_all_valid();
524 
525 	return true;
526 }
527 
sym_toggle_tristate_value(struct symbol * sym)528 tristate sym_toggle_tristate_value(struct symbol *sym)
529 {
530 	tristate oldval, newval;
531 
532 	oldval = newval = sym_get_tristate_value(sym);
533 	do {
534 		switch (newval) {
535 		case no:
536 			newval = mod;
537 			break;
538 		case mod:
539 			newval = yes;
540 			break;
541 		case yes:
542 			newval = no;
543 			break;
544 		}
545 		if (sym_set_tristate_value(sym, newval))
546 			break;
547 	} while (oldval != newval);
548 	return newval;
549 }
550 
sym_string_valid(struct symbol * sym,const char * str)551 bool sym_string_valid(struct symbol *sym, const char *str)
552 {
553 	signed char ch;
554 
555 	switch (sym->type) {
556 	case S_STRING:
557 		return true;
558 	case S_INT:
559 		ch = *str++;
560 		if (ch == '-')
561 			ch = *str++;
562 		if (!isdigit(ch))
563 			return false;
564 		if (ch == '0' && *str != 0)
565 			return false;
566 		while ((ch = *str++)) {
567 			if (!isdigit(ch))
568 				return false;
569 		}
570 		return true;
571 	case S_HEX:
572 		if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
573 			str += 2;
574 		ch = *str++;
575 		do {
576 			if (!isxdigit(ch))
577 				return false;
578 		} while ((ch = *str++));
579 		return true;
580 	case S_BOOLEAN:
581 	case S_TRISTATE:
582 		switch (str[0]) {
583 		case 'y': case 'Y':
584 		case 'm': case 'M':
585 		case 'n': case 'N':
586 			return true;
587 		}
588 		return false;
589 	default:
590 		return false;
591 	}
592 }
593 
sym_string_within_range(struct symbol * sym,const char * str)594 bool sym_string_within_range(struct symbol *sym, const char *str)
595 {
596 	struct property *prop;
597 	long long val;
598 
599 	switch (sym->type) {
600 	case S_STRING:
601 		return sym_string_valid(sym, str);
602 	case S_INT:
603 		if (!sym_string_valid(sym, str))
604 			return false;
605 		prop = sym_get_range_prop(sym);
606 		if (!prop)
607 			return true;
608 		val = strtoll(str, NULL, 10);
609 		return val >= sym_get_range_val(prop->expr->left.sym, 10) &&
610 		       val <= sym_get_range_val(prop->expr->right.sym, 10);
611 	case S_HEX:
612 		if (!sym_string_valid(sym, str))
613 			return false;
614 		prop = sym_get_range_prop(sym);
615 		if (!prop)
616 			return true;
617 		val = strtoll(str, NULL, 16);
618 		return val >= sym_get_range_val(prop->expr->left.sym, 16) &&
619 		       val <= sym_get_range_val(prop->expr->right.sym, 16);
620 	case S_BOOLEAN:
621 	case S_TRISTATE:
622 		switch (str[0]) {
623 		case 'y': case 'Y':
624 			return sym_tristate_within_range(sym, yes);
625 		case 'm': case 'M':
626 			return sym_tristate_within_range(sym, mod);
627 		case 'n': case 'N':
628 			return sym_tristate_within_range(sym, no);
629 		}
630 		return false;
631 	default:
632 		return false;
633 	}
634 }
635 
sym_set_string_value(struct symbol * sym,const char * newval)636 bool sym_set_string_value(struct symbol *sym, const char *newval)
637 {
638 	const char *oldval;
639 	char *val;
640 	int size;
641 
642 	switch (sym->type) {
643 	case S_BOOLEAN:
644 	case S_TRISTATE:
645 		switch (newval[0]) {
646 		case 'y': case 'Y':
647 			return sym_set_tristate_value(sym, yes);
648 		case 'm': case 'M':
649 			return sym_set_tristate_value(sym, mod);
650 		case 'n': case 'N':
651 			return sym_set_tristate_value(sym, no);
652 		}
653 		return false;
654 	default:
655 		;
656 	}
657 
658 	if (!sym_string_within_range(sym, newval))
659 		return false;
660 
661 	if (!(sym->flags & SYMBOL_DEF_USER)) {
662 		sym->flags |= SYMBOL_DEF_USER;
663 		sym_set_changed(sym);
664 	}
665 
666 	oldval = sym->def[S_DEF_USER].val;
667 	size = strlen(newval) + 1;
668 	if (sym->type == S_HEX && (newval[0] != '0' || (newval[1] != 'x' && newval[1] != 'X'))) {
669 		size += 2;
670 		sym->def[S_DEF_USER].val = val = xmalloc(size);
671 		*val++ = '0';
672 		*val++ = 'x';
673 	} else if (!oldval || strcmp(oldval, newval))
674 		sym->def[S_DEF_USER].val = val = xmalloc(size);
675 	else
676 		return true;
677 
678 	strcpy(val, newval);
679 	free((void *)oldval);
680 	sym_clear_all_valid();
681 
682 	return true;
683 }
684 
685 /*
686  * Find the default value associated to a symbol.
687  * For tristate symbol handle the modules=n case
688  * in which case "m" becomes "y".
689  * If the symbol does not have any default then fallback
690  * to the fixed default values.
691  */
sym_get_string_default(struct symbol * sym)692 const char *sym_get_string_default(struct symbol *sym)
693 {
694 	struct property *prop;
695 	struct symbol *ds;
696 	const char *str;
697 	tristate val;
698 
699 	sym_calc_visibility(sym);
700 	sym_calc_value(modules_sym);
701 	val = symbol_no.curr.tri;
702 	str = symbol_empty.curr.val;
703 
704 	/* If symbol has a default value look it up */
705 	prop = sym_get_default_prop(sym);
706 	if (prop != NULL) {
707 		switch (sym->type) {
708 		case S_BOOLEAN:
709 		case S_TRISTATE:
710 			/* The visibility may limit the value from yes => mod */
711 			val = EXPR_AND(expr_calc_value(prop->expr), prop->visible.tri);
712 			break;
713 		default:
714 			/*
715 			 * The following fails to handle the situation
716 			 * where a default value is further limited by
717 			 * the valid range.
718 			 */
719 			ds = prop_get_symbol(prop);
720 			if (ds != NULL) {
721 				sym_calc_value(ds);
722 				str = (const char *)ds->curr.val;
723 			}
724 		}
725 	}
726 
727 	/* Handle select statements */
728 	val = EXPR_OR(val, sym->rev_dep.tri);
729 
730 	/* transpose mod to yes if modules are not enabled */
731 	if (val == mod)
732 		if (!sym_is_choice_value(sym) && modules_sym->curr.tri == no)
733 			val = yes;
734 
735 	/* transpose mod to yes if type is bool */
736 	if (sym->type == S_BOOLEAN && val == mod)
737 		val = yes;
738 
739 	switch (sym->type) {
740 	case S_BOOLEAN:
741 	case S_TRISTATE:
742 		switch (val) {
743 		case no: return "n";
744 		case mod: return "m";
745 		case yes: return "y";
746 		}
747 	case S_INT:
748 	case S_HEX:
749 		return str;
750 	case S_STRING:
751 		return str;
752 	case S_OTHER:
753 	case S_UNKNOWN:
754 		break;
755 	}
756 	return "";
757 }
758 
sym_get_string_value(struct symbol * sym)759 const char *sym_get_string_value(struct symbol *sym)
760 {
761 	tristate val;
762 
763 	switch (sym->type) {
764 	case S_BOOLEAN:
765 	case S_TRISTATE:
766 		val = sym_get_tristate_value(sym);
767 		switch (val) {
768 		case no:
769 			return "n";
770 		case mod:
771 			sym_calc_value(modules_sym);
772 			return (modules_sym->curr.tri == no) ? "n" : "m";
773 		case yes:
774 			return "y";
775 		}
776 		break;
777 	default:
778 		;
779 	}
780 	return (const char *)sym->curr.val;
781 }
782 
sym_is_changable(struct symbol * sym)783 bool sym_is_changable(struct symbol *sym)
784 {
785 	return sym->visible > sym->rev_dep.tri;
786 }
787 
strhash(const char * s)788 static unsigned strhash(const char *s)
789 {
790 	/* fnv32 hash */
791 	unsigned hash = 2166136261U;
792 	for (; *s; s++)
793 		hash = (hash ^ *s) * 0x01000193;
794 	return hash;
795 }
796 
sym_lookup(const char * name,int flags)797 struct symbol *sym_lookup(const char *name, int flags)
798 {
799 	struct symbol *symbol;
800 	char *new_name;
801 	int hash;
802 
803 	if (name) {
804 		if (name[0] && !name[1]) {
805 			switch (name[0]) {
806 			case 'y': return &symbol_yes;
807 			case 'm': return &symbol_mod;
808 			case 'n': return &symbol_no;
809 			}
810 		}
811 		hash = strhash(name) % SYMBOL_HASHSIZE;
812 
813 		for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
814 			if (symbol->name &&
815 			    !strcmp(symbol->name, name) &&
816 			    (flags ? symbol->flags & flags
817 				   : !(symbol->flags & (SYMBOL_CONST|SYMBOL_CHOICE))))
818 				return symbol;
819 		}
820 		new_name = strdup(name);
821 	} else {
822 		new_name = NULL;
823 		hash = 0;
824 	}
825 
826 	symbol = xmalloc(sizeof(*symbol));
827 	memset(symbol, 0, sizeof(*symbol));
828 	symbol->name = new_name;
829 	symbol->type = S_UNKNOWN;
830 	symbol->flags |= flags;
831 
832 	symbol->next = symbol_hash[hash];
833 	symbol_hash[hash] = symbol;
834 
835 	return symbol;
836 }
837 
sym_find(const char * name)838 struct symbol *sym_find(const char *name)
839 {
840 	struct symbol *symbol = NULL;
841 	int hash = 0;
842 
843 	if (!name)
844 		return NULL;
845 
846 	if (name[0] && !name[1]) {
847 		switch (name[0]) {
848 		case 'y': return &symbol_yes;
849 		case 'm': return &symbol_mod;
850 		case 'n': return &symbol_no;
851 		}
852 	}
853 	hash = strhash(name) % SYMBOL_HASHSIZE;
854 
855 	for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
856 		if (symbol->name &&
857 		    !strcmp(symbol->name, name) &&
858 		    !(symbol->flags & SYMBOL_CONST))
859 				break;
860 	}
861 
862 	return symbol;
863 }
864 
865 /*
866  * Expand symbol's names embedded in the string given in argument. Symbols'
867  * name to be expanded shall be prefixed by a '$'. Unknown symbol expands to
868  * the empty string.
869  */
sym_expand_string_value(const char * in)870 const char *sym_expand_string_value(const char *in)
871 {
872 	const char *src;
873 	char *res;
874 	size_t reslen;
875 
876 	reslen = strlen(in) + 1;
877 	res = xmalloc(reslen);
878 	res[0] = '\0';
879 
880 	while ((src = strchr(in, '$'))) {
881 		char *p, name[SYMBOL_MAXLENGTH];
882 		const char *symval = "";
883 		struct symbol *sym;
884 		size_t newlen;
885 
886 		strncat(res, in, src - in);
887 		src++;
888 
889 		p = name;
890 		while (isalnum(*src) || *src == '_')
891 			*p++ = *src++;
892 		*p = '\0';
893 
894 		sym = sym_find(name);
895 		if (sym != NULL) {
896 			sym_calc_value(sym);
897 			symval = sym_get_string_value(sym);
898 		}
899 
900 		newlen = strlen(res) + strlen(symval) + strlen(src) + 1;
901 		if (newlen > reslen) {
902 			reslen = newlen;
903 			res = realloc(res, reslen);
904 		}
905 
906 		strcat(res, symval);
907 		in = src;
908 	}
909 	strcat(res, in);
910 
911 	return res;
912 }
913 
sym_escape_string_value(const char * in)914 const char *sym_escape_string_value(const char *in)
915 {
916 	const char *p;
917 	size_t reslen;
918 	char *res;
919 	size_t l;
920 
921 	reslen = strlen(in) + strlen("\"\"") + 1;
922 
923 	p = in;
924 	for (;;) {
925 		l = strcspn(p, "\"\\");
926 		p += l;
927 
928 		if (p[0] == '\0')
929 			break;
930 
931 		reslen++;
932 		p++;
933 	}
934 
935 	res = xmalloc(reslen);
936 	res[0] = '\0';
937 
938 	strcat(res, "\"");
939 
940 	p = in;
941 	for (;;) {
942 		l = strcspn(p, "\"\\");
943 		strncat(res, p, l);
944 		p += l;
945 
946 		if (p[0] == '\0')
947 			break;
948 
949 		strcat(res, "\\");
950 		strncat(res, p++, 1);
951 	}
952 
953 	strcat(res, "\"");
954 	return res;
955 }
956 
957 struct sym_match {
958 	struct symbol	*sym;
959 	off_t		so, eo;
960 };
961 
962 /* Compare matched symbols as thus:
963  * - first, symbols that match exactly
964  * - then, alphabetical sort
965  */
sym_rel_comp(const void * sym1,const void * sym2)966 static int sym_rel_comp(const void *sym1, const void *sym2)
967 {
968 	const struct sym_match *s1 = sym1;
969 	const struct sym_match *s2 = sym2;
970 	int exact1, exact2;
971 
972 	/* Exact match:
973 	 * - if matched length on symbol s1 is the length of that symbol,
974 	 *   then this symbol should come first;
975 	 * - if matched length on symbol s2 is the length of that symbol,
976 	 *   then this symbol should come first.
977 	 * Note: since the search can be a regexp, both symbols may match
978 	 * exactly; if this is the case, we can't decide which comes first,
979 	 * and we fallback to sorting alphabetically.
980 	 */
981 	exact1 = (s1->eo - s1->so) == strlen(s1->sym->name);
982 	exact2 = (s2->eo - s2->so) == strlen(s2->sym->name);
983 	if (exact1 && !exact2)
984 		return -1;
985 	if (!exact1 && exact2)
986 		return 1;
987 
988 	/* As a fallback, sort symbols alphabetically */
989 	return strcmp(s1->sym->name, s2->sym->name);
990 }
991 
sym_re_search(const char * pattern)992 struct symbol **sym_re_search(const char *pattern)
993 {
994 	struct symbol *sym, **sym_arr = NULL;
995 	struct sym_match *sym_match_arr = NULL;
996 	int i, cnt, size;
997 	regex_t re;
998 	regmatch_t match[1];
999 
1000 	cnt = size = 0;
1001 	/* Skip if empty */
1002 	if (strlen(pattern) == 0)
1003 		return NULL;
1004 	if (regcomp(&re, pattern, REG_EXTENDED|REG_ICASE))
1005 		return NULL;
1006 
1007 	for_all_symbols(i, sym) {
1008 		if (sym->flags & SYMBOL_CONST || !sym->name)
1009 			continue;
1010 		if (regexec(&re, sym->name, 1, match, 0))
1011 			continue;
1012 		if (cnt >= size) {
1013 			void *tmp;
1014 			size += 16;
1015 			tmp = realloc(sym_match_arr, size * sizeof(struct sym_match));
1016 			if (!tmp)
1017 				goto sym_re_search_free;
1018 			sym_match_arr = tmp;
1019 		}
1020 		sym_calc_value(sym);
1021 		/* As regexec returned 0, we know we have a match, so
1022 		 * we can use match[0].rm_[se]o without further checks
1023 		 */
1024 		sym_match_arr[cnt].so = match[0].rm_so;
1025 		sym_match_arr[cnt].eo = match[0].rm_eo;
1026 		sym_match_arr[cnt++].sym = sym;
1027 	}
1028 	if (sym_match_arr) {
1029 		qsort(sym_match_arr, cnt, sizeof(struct sym_match), sym_rel_comp);
1030 		sym_arr = malloc((cnt+1) * sizeof(struct symbol));
1031 		if (!sym_arr)
1032 			goto sym_re_search_free;
1033 		for (i = 0; i < cnt; i++)
1034 			sym_arr[i] = sym_match_arr[i].sym;
1035 		sym_arr[cnt] = NULL;
1036 	}
1037 sym_re_search_free:
1038 	/* sym_match_arr can be NULL if no match, but free(NULL) is OK */
1039 	free(sym_match_arr);
1040 	regfree(&re);
1041 
1042 	return sym_arr;
1043 }
1044 
1045 /*
1046  * When we check for recursive dependencies we use a stack to save
1047  * current state so we can print out relevant info to user.
1048  * The entries are located on the call stack so no need to free memory.
1049  * Note insert() remove() must always match to properly clear the stack.
1050  */
1051 static struct dep_stack {
1052 	struct dep_stack *prev, *next;
1053 	struct symbol *sym;
1054 	struct property *prop;
1055 	struct expr *expr;
1056 } *check_top;
1057 
dep_stack_insert(struct dep_stack * stack,struct symbol * sym)1058 static void dep_stack_insert(struct dep_stack *stack, struct symbol *sym)
1059 {
1060 	memset(stack, 0, sizeof(*stack));
1061 	if (check_top)
1062 		check_top->next = stack;
1063 	stack->prev = check_top;
1064 	stack->sym = sym;
1065 	check_top = stack;
1066 }
1067 
dep_stack_remove(void)1068 static void dep_stack_remove(void)
1069 {
1070 	check_top = check_top->prev;
1071 	if (check_top)
1072 		check_top->next = NULL;
1073 }
1074 
1075 /*
1076  * Called when we have detected a recursive dependency.
1077  * check_top point to the top of the stact so we use
1078  * the ->prev pointer to locate the bottom of the stack.
1079  */
sym_check_print_recursive(struct symbol * last_sym)1080 static void sym_check_print_recursive(struct symbol *last_sym)
1081 {
1082 	struct dep_stack *stack;
1083 	struct symbol *sym, *next_sym;
1084 	struct menu *menu = NULL;
1085 	struct property *prop;
1086 	struct dep_stack cv_stack;
1087 
1088 	if (sym_is_choice_value(last_sym)) {
1089 		dep_stack_insert(&cv_stack, last_sym);
1090 		last_sym = prop_get_symbol(sym_get_choice_prop(last_sym));
1091 	}
1092 
1093 	for (stack = check_top; stack != NULL; stack = stack->prev)
1094 		if (stack->sym == last_sym)
1095 			break;
1096 	if (!stack) {
1097 		fprintf(stderr, "unexpected recursive dependency error\n");
1098 		return;
1099 	}
1100 
1101 	for (; stack; stack = stack->next) {
1102 		sym = stack->sym;
1103 		next_sym = stack->next ? stack->next->sym : last_sym;
1104 		prop = stack->prop;
1105 		if (prop == NULL)
1106 			prop = stack->sym->prop;
1107 
1108 		/* for choice values find the menu entry (used below) */
1109 		if (sym_is_choice(sym) || sym_is_choice_value(sym)) {
1110 			for (prop = sym->prop; prop; prop = prop->next) {
1111 				menu = prop->menu;
1112 				if (prop->menu)
1113 					break;
1114 			}
1115 		}
1116 		if (stack->sym == last_sym)
1117 			fprintf(stderr, "%s:%d:error: recursive dependency detected!\n",
1118 				prop->file->name, prop->lineno);
1119 			fprintf(stderr, "For a resolution refer to Documentation/kbuild/kconfig-language.txt\n");
1120 			fprintf(stderr, "subsection \"Kconfig recursive dependency limitations\"\n");
1121 		if (stack->expr) {
1122 			fprintf(stderr, "%s:%d:\tsymbol %s %s value contains %s\n",
1123 				prop->file->name, prop->lineno,
1124 				sym->name ? sym->name : "<choice>",
1125 				prop_get_type_name(prop->type),
1126 				next_sym->name ? next_sym->name : "<choice>");
1127 		} else if (stack->prop) {
1128 			fprintf(stderr, "%s:%d:\tsymbol %s depends on %s\n",
1129 				prop->file->name, prop->lineno,
1130 				sym->name ? sym->name : "<choice>",
1131 				next_sym->name ? next_sym->name : "<choice>");
1132 		} else if (sym_is_choice(sym)) {
1133 			fprintf(stderr, "%s:%d:\tchoice %s contains symbol %s\n",
1134 				menu->file->name, menu->lineno,
1135 				sym->name ? sym->name : "<choice>",
1136 				next_sym->name ? next_sym->name : "<choice>");
1137 		} else if (sym_is_choice_value(sym)) {
1138 			fprintf(stderr, "%s:%d:\tsymbol %s is part of choice %s\n",
1139 				menu->file->name, menu->lineno,
1140 				sym->name ? sym->name : "<choice>",
1141 				next_sym->name ? next_sym->name : "<choice>");
1142 		} else {
1143 			fprintf(stderr, "%s:%d:\tsymbol %s is selected by %s\n",
1144 				prop->file->name, prop->lineno,
1145 				sym->name ? sym->name : "<choice>",
1146 				next_sym->name ? next_sym->name : "<choice>");
1147 		}
1148 	}
1149 
1150 	if (check_top == &cv_stack)
1151 		dep_stack_remove();
1152 }
1153 
sym_check_expr_deps(struct expr * e)1154 static struct symbol *sym_check_expr_deps(struct expr *e)
1155 {
1156 	struct symbol *sym;
1157 
1158 	if (!e)
1159 		return NULL;
1160 	switch (e->type) {
1161 	case E_OR:
1162 	case E_AND:
1163 		sym = sym_check_expr_deps(e->left.expr);
1164 		if (sym)
1165 			return sym;
1166 		return sym_check_expr_deps(e->right.expr);
1167 	case E_NOT:
1168 		return sym_check_expr_deps(e->left.expr);
1169 	case E_EQUAL:
1170 	case E_GEQ:
1171 	case E_GTH:
1172 	case E_LEQ:
1173 	case E_LTH:
1174 	case E_UNEQUAL:
1175 		sym = sym_check_deps(e->left.sym);
1176 		if (sym)
1177 			return sym;
1178 		return sym_check_deps(e->right.sym);
1179 	case E_SYMBOL:
1180 		return sym_check_deps(e->left.sym);
1181 	default:
1182 		break;
1183 	}
1184 	printf("Oops! How to check %d?\n", e->type);
1185 	return NULL;
1186 }
1187 
1188 /* return NULL when dependencies are OK */
sym_check_sym_deps(struct symbol * sym)1189 static struct symbol *sym_check_sym_deps(struct symbol *sym)
1190 {
1191 	struct symbol *sym2;
1192 	struct property *prop;
1193 	struct dep_stack stack;
1194 
1195 	dep_stack_insert(&stack, sym);
1196 
1197 	sym2 = sym_check_expr_deps(sym->rev_dep.expr);
1198 	if (sym2)
1199 		goto out;
1200 
1201 	for (prop = sym->prop; prop; prop = prop->next) {
1202 		if (prop->type == P_CHOICE || prop->type == P_SELECT)
1203 			continue;
1204 		stack.prop = prop;
1205 		sym2 = sym_check_expr_deps(prop->visible.expr);
1206 		if (sym2)
1207 			break;
1208 		if (prop->type != P_DEFAULT || sym_is_choice(sym))
1209 			continue;
1210 		stack.expr = prop->expr;
1211 		sym2 = sym_check_expr_deps(prop->expr);
1212 		if (sym2)
1213 			break;
1214 		stack.expr = NULL;
1215 	}
1216 
1217 out:
1218 	dep_stack_remove();
1219 
1220 	return sym2;
1221 }
1222 
sym_check_choice_deps(struct symbol * choice)1223 static struct symbol *sym_check_choice_deps(struct symbol *choice)
1224 {
1225 	struct symbol *sym, *sym2;
1226 	struct property *prop;
1227 	struct expr *e;
1228 	struct dep_stack stack;
1229 
1230 	dep_stack_insert(&stack, choice);
1231 
1232 	prop = sym_get_choice_prop(choice);
1233 	expr_list_for_each_sym(prop->expr, e, sym)
1234 		sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
1235 
1236 	choice->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
1237 	sym2 = sym_check_sym_deps(choice);
1238 	choice->flags &= ~SYMBOL_CHECK;
1239 	if (sym2)
1240 		goto out;
1241 
1242 	expr_list_for_each_sym(prop->expr, e, sym) {
1243 		sym2 = sym_check_sym_deps(sym);
1244 		if (sym2)
1245 			break;
1246 	}
1247 out:
1248 	expr_list_for_each_sym(prop->expr, e, sym)
1249 		sym->flags &= ~SYMBOL_CHECK;
1250 
1251 	if (sym2 && sym_is_choice_value(sym2) &&
1252 	    prop_get_symbol(sym_get_choice_prop(sym2)) == choice)
1253 		sym2 = choice;
1254 
1255 	dep_stack_remove();
1256 
1257 	return sym2;
1258 }
1259 
sym_check_deps(struct symbol * sym)1260 struct symbol *sym_check_deps(struct symbol *sym)
1261 {
1262 	struct symbol *sym2;
1263 	struct property *prop;
1264 
1265 	if (sym->flags & SYMBOL_CHECK) {
1266 		sym_check_print_recursive(sym);
1267 		return sym;
1268 	}
1269 	if (sym->flags & SYMBOL_CHECKED)
1270 		return NULL;
1271 
1272 	if (sym_is_choice_value(sym)) {
1273 		struct dep_stack stack;
1274 
1275 		/* for choice groups start the check with main choice symbol */
1276 		dep_stack_insert(&stack, sym);
1277 		prop = sym_get_choice_prop(sym);
1278 		sym2 = sym_check_deps(prop_get_symbol(prop));
1279 		dep_stack_remove();
1280 	} else if (sym_is_choice(sym)) {
1281 		sym2 = sym_check_choice_deps(sym);
1282 	} else {
1283 		sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
1284 		sym2 = sym_check_sym_deps(sym);
1285 		sym->flags &= ~SYMBOL_CHECK;
1286 	}
1287 
1288 	if (sym2 && sym2 == sym)
1289 		sym2 = NULL;
1290 
1291 	return sym2;
1292 }
1293 
prop_alloc(enum prop_type type,struct symbol * sym)1294 struct property *prop_alloc(enum prop_type type, struct symbol *sym)
1295 {
1296 	struct property *prop;
1297 	struct property **propp;
1298 
1299 	prop = xmalloc(sizeof(*prop));
1300 	memset(prop, 0, sizeof(*prop));
1301 	prop->type = type;
1302 	prop->sym = sym;
1303 	prop->file = current_file;
1304 	prop->lineno = zconf_lineno();
1305 
1306 	/* append property to the prop list of symbol */
1307 	if (sym) {
1308 		for (propp = &sym->prop; *propp; propp = &(*propp)->next)
1309 			;
1310 		*propp = prop;
1311 	}
1312 
1313 	return prop;
1314 }
1315 
prop_get_symbol(struct property * prop)1316 struct symbol *prop_get_symbol(struct property *prop)
1317 {
1318 	if (prop->expr && (prop->expr->type == E_SYMBOL ||
1319 			   prop->expr->type == E_LIST))
1320 		return prop->expr->left.sym;
1321 	return NULL;
1322 }
1323 
prop_get_type_name(enum prop_type type)1324 const char *prop_get_type_name(enum prop_type type)
1325 {
1326 	switch (type) {
1327 	case P_PROMPT:
1328 		return "prompt";
1329 	case P_ENV:
1330 		return "env";
1331 	case P_COMMENT:
1332 		return "comment";
1333 	case P_MENU:
1334 		return "menu";
1335 	case P_DEFAULT:
1336 		return "default";
1337 	case P_CHOICE:
1338 		return "choice";
1339 	case P_SELECT:
1340 		return "select";
1341 	case P_RANGE:
1342 		return "range";
1343 	case P_SYMBOL:
1344 		return "symbol";
1345 	case P_UNKNOWN:
1346 		break;
1347 	}
1348 	return "unknown";
1349 }
1350 
prop_add_env(const char * env)1351 static void prop_add_env(const char *env)
1352 {
1353 	struct symbol *sym, *sym2;
1354 	struct property *prop;
1355 	char *p;
1356 
1357 	sym = current_entry->sym;
1358 	sym->flags |= SYMBOL_AUTO;
1359 	for_all_properties(sym, prop, P_ENV) {
1360 		sym2 = prop_get_symbol(prop);
1361 		if (strcmp(sym2->name, env))
1362 			menu_warn(current_entry, "redefining environment symbol from %s",
1363 				  sym2->name);
1364 		return;
1365 	}
1366 
1367 	prop = prop_alloc(P_ENV, sym);
1368 	prop->expr = expr_alloc_symbol(sym_lookup(env, SYMBOL_CONST));
1369 
1370 	sym_env_list = expr_alloc_one(E_LIST, sym_env_list);
1371 	sym_env_list->right.sym = sym;
1372 
1373 	p = getenv(env);
1374 	if (p)
1375 		sym_add_default(sym, p);
1376 	else
1377 		menu_warn(current_entry, "environment variable %s undefined", env);
1378 }
1379