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