![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to confdata.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / tools / kconfig|
Return to confdata.c CVS log | Up to [Qemu by Fabrice Bellard] / qemu / roms / seabios / tools / kconfig |
1.1 root 1: /*
2: * Copyright (C) 2002 Roman Zippel <[email protected]>
3: * Released under the terms of the GNU GPL v2.0.
4: */
5:
6: #include <sys/stat.h>
7: #include <ctype.h>
8: #include <errno.h>
9: #include <fcntl.h>
10: #include <stdio.h>
11: #include <stdlib.h>
12: #include <string.h>
13: #include <time.h>
14: #include <unistd.h>
15:
16: #define LKC_DIRECT_LINK
17: #include "lkc.h"
18:
19: static void conf_warning(const char *fmt, ...)
20: __attribute__ ((format (printf, 1, 2)));
21:
22: static void conf_message(const char *fmt, ...)
23: __attribute__ ((format (printf, 1, 2)));
24:
25: static const char *conf_filename;
26: static int conf_lineno, conf_warnings, conf_unsaved;
27:
28: const char conf_defname[] = "arch/$ARCH/defconfig";
29:
30: static void conf_warning(const char *fmt, ...)
31: {
32: va_list ap;
33: va_start(ap, fmt);
34: fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
35: vfprintf(stderr, fmt, ap);
36: fprintf(stderr, "\n");
37: va_end(ap);
38: conf_warnings++;
39: }
40:
41: static void conf_default_message_callback(const char *fmt, va_list ap)
42: {
43: printf("#\n# ");
44: vprintf(fmt, ap);
45: printf("\n#\n");
46: }
47:
48: static void (*conf_message_callback) (const char *fmt, va_list ap) =
49: conf_default_message_callback;
50: void conf_set_message_callback(void (*fn) (const char *fmt, va_list ap))
51: {
52: conf_message_callback = fn;
53: }
54:
55: static void conf_message(const char *fmt, ...)
56: {
57: va_list ap;
58:
59: va_start(ap, fmt);
60: if (conf_message_callback)
61: conf_message_callback(fmt, ap);
62: }
63:
64: const char *conf_get_configname(void)
65: {
66: char *name = getenv("KCONFIG_CONFIG");
67:
68: return name ? name : ".config";
69: }
70:
71: const char *conf_get_autoconfig_name(void)
72: {
73: char *name = getenv("KCONFIG_AUTOCONFIG");
74:
75: return name ? name : "include/config/auto.conf";
76: }
77:
78: static char *conf_expand_value(const char *in)
79: {
80: struct symbol *sym;
81: const char *src;
82: static char res_value[SYMBOL_MAXLENGTH];
83: char *dst, name[SYMBOL_MAXLENGTH];
84:
85: res_value[0] = 0;
86: dst = name;
87: while ((src = strchr(in, '$'))) {
88: strncat(res_value, in, src - in);
89: src++;
90: dst = name;
91: while (isalnum(*src) || *src == '_')
92: *dst++ = *src++;
93: *dst = 0;
94: sym = sym_lookup(name, 0);
95: sym_calc_value(sym);
96: strcat(res_value, sym_get_string_value(sym));
97: in = src;
98: }
99: strcat(res_value, in);
100:
101: return res_value;
102: }
103:
104: char *conf_get_default_confname(void)
105: {
106: struct stat buf;
107: static char fullname[PATH_MAX+1];
108: char *env, *name;
109:
110: name = conf_expand_value(conf_defname);
111: env = getenv(SRCTREE);
112: if (env) {
113: sprintf(fullname, "%s/%s", env, name);
114: if (!stat(fullname, &buf))
115: return fullname;
116: }
117: return name;
118: }
119:
120: static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
121: {
122: char *p2;
123:
124: switch (sym->type) {
125: case S_TRISTATE:
126: if (p[0] == 'm') {
127: sym->def[def].tri = mod;
128: sym->flags |= def_flags;
129: break;
130: }
131: case S_BOOLEAN:
132: if (p[0] == 'y') {
133: sym->def[def].tri = yes;
134: sym->flags |= def_flags;
135: break;
136: }
137: if (p[0] == 'n') {
138: sym->def[def].tri = no;
139: sym->flags |= def_flags;
140: break;
141: }
142: conf_warning("symbol value '%s' invalid for %s", p, sym->name);
143: break;
144: case S_OTHER:
145: if (*p != '"') {
146: for (p2 = p; *p2 && !isspace(*p2); p2++)
147: ;
148: sym->type = S_STRING;
149: goto done;
150: }
151: case S_STRING:
152: if (*p++ != '"')
153: break;
154: for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
155: if (*p2 == '"') {
156: *p2 = 0;
157: break;
158: }
159: memmove(p2, p2 + 1, strlen(p2));
160: }
161: if (!p2) {
162: conf_warning("invalid string found");
163: return 1;
164: }
165: case S_INT:
166: case S_HEX:
167: done:
168: if (sym_string_valid(sym, p)) {
169: sym->def[def].val = strdup(p);
170: sym->flags |= def_flags;
171: } else {
172: conf_warning("symbol value '%s' invalid for %s", p, sym->name);
173: return 1;
174: }
175: break;
176: default:
177: ;
178: }
179: return 0;
180: }
181:
182: int conf_read_simple(const char *name, int def)
183: {
184: FILE *in = NULL;
185: char line[1024];
186: char *p, *p2;
187: struct symbol *sym;
188: int i, def_flags;
189:
190: if (name) {
191: in = zconf_fopen(name);
192: } else {
193: struct property *prop;
194:
195: name = conf_get_configname();
196: in = zconf_fopen(name);
197: if (in)
198: goto load;
199: sym_add_change_count(1);
200: if (!sym_defconfig_list) {
201: if (modules_sym)
202: sym_calc_value(modules_sym);
203: return 1;
204: }
205:
206: for_all_defaults(sym_defconfig_list, prop) {
207: if (expr_calc_value(prop->visible.expr) == no ||
208: prop->expr->type != E_SYMBOL)
209: continue;
210: name = conf_expand_value(prop->expr->left.sym->name);
211: in = zconf_fopen(name);
212: if (in) {
213: conf_message(_("using defaults found in %s"),
214: name);
215: goto load;
216: }
217: }
218: }
219: if (!in)
220: return 1;
221:
222: load:
223: conf_filename = name;
224: conf_lineno = 0;
225: conf_warnings = 0;
226: conf_unsaved = 0;
227:
228: def_flags = SYMBOL_DEF << def;
229: for_all_symbols(i, sym) {
230: sym->flags |= SYMBOL_CHANGED;
231: sym->flags &= ~(def_flags|SYMBOL_VALID);
232: if (sym_is_choice(sym))
233: sym->flags |= def_flags;
234: switch (sym->type) {
235: case S_INT:
236: case S_HEX:
237: case S_STRING:
238: if (sym->def[def].val)
239: free(sym->def[def].val);
240: default:
241: sym->def[def].val = NULL;
242: sym->def[def].tri = no;
243: }
244: }
245:
246: while (fgets(line, sizeof(line), in)) {
247: conf_lineno++;
248: sym = NULL;
249: if (line[0] == '#') {
250: if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))
251: continue;
252: p = strchr(line + 2 + strlen(CONFIG_), ' ');
253: if (!p)
254: continue;
255: *p++ = 0;
256: if (strncmp(p, "is not set", 10))
257: continue;
258: if (def == S_DEF_USER) {
259: sym = sym_find(line + 2 + strlen(CONFIG_));
260: if (!sym) {
261: sym_add_change_count(1);
262: goto setsym;
263: }
264: } else {
265: sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);
266: if (sym->type == S_UNKNOWN)
267: sym->type = S_BOOLEAN;
268: }
269: if (sym->flags & def_flags) {
270: conf_warning("override: reassigning to symbol %s", sym->name);
271: }
272: switch (sym->type) {
273: case S_BOOLEAN:
274: case S_TRISTATE:
275: sym->def[def].tri = no;
276: sym->flags |= def_flags;
277: break;
278: default:
279: ;
280: }
281: } else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {
282: p = strchr(line + strlen(CONFIG_), '=');
283: if (!p)
284: continue;
285: *p++ = 0;
286: p2 = strchr(p, '\n');
287: if (p2) {
288: *p2-- = 0;
289: if (*p2 == '\r')
290: *p2 = 0;
291: }
292: if (def == S_DEF_USER) {
293: sym = sym_find(line + strlen(CONFIG_));
294: if (!sym) {
295: sym_add_change_count(1);
296: goto setsym;
297: }
298: } else {
299: sym = sym_lookup(line + strlen(CONFIG_), 0);
300: if (sym->type == S_UNKNOWN)
301: sym->type = S_OTHER;
302: }
303: if (sym->flags & def_flags) {
304: conf_warning("override: reassigning to symbol %s", sym->name);
305: }
306: if (conf_set_sym_val(sym, def, def_flags, p))
307: continue;
308: } else {
309: if (line[0] != '\r' && line[0] != '\n')
310: conf_warning("unexpected data");
311: continue;
312: }
313: setsym:
314: if (sym && sym_is_choice_value(sym)) {
315: struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
316: switch (sym->def[def].tri) {
317: case no:
318: break;
319: case mod:
320: if (cs->def[def].tri == yes) {
321: conf_warning("%s creates inconsistent choice state", sym->name);
322: cs->flags &= ~def_flags;
323: }
324: break;
325: case yes:
326: if (cs->def[def].tri != no)
327: conf_warning("override: %s changes choice state", sym->name);
328: cs->def[def].val = sym;
329: break;
330: }
331: cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri);
332: }
333: }
334: fclose(in);
335:
336: if (modules_sym)
337: sym_calc_value(modules_sym);
338: return 0;
339: }
340:
341: int conf_read(const char *name)
342: {
343: struct symbol *sym, *choice_sym;
344: struct property *prop;
345: struct expr *e;
346: int i, flags;
347:
348: sym_set_change_count(0);
349:
350: if (conf_read_simple(name, S_DEF_USER))
351: return 1;
352:
353: for_all_symbols(i, sym) {
354: sym_calc_value(sym);
355: if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
356: goto sym_ok;
357: if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
358: /* check that calculated value agrees with saved value */
359: switch (sym->type) {
360: case S_BOOLEAN:
361: case S_TRISTATE:
362: if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
363: break;
364: if (!sym_is_choice(sym))
365: goto sym_ok;
366: default:
367: if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
368: goto sym_ok;
369: break;
370: }
371: } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
372: /* no previous value and not saved */
373: goto sym_ok;
374: conf_unsaved++;
375: /* maybe print value in verbose mode... */
376: sym_ok:
377: if (!sym_is_choice(sym))
378: continue;
379: /* The choice symbol only has a set value (and thus is not new)
380: * if all its visible childs have values.
381: */
382: prop = sym_get_choice_prop(sym);
383: flags = sym->flags;
384: expr_list_for_each_sym(prop->expr, e, choice_sym)
385: if (choice_sym->visible != no)
386: flags &= choice_sym->flags;
387: sym->flags &= flags | ~SYMBOL_DEF_USER;
388: }
389:
390: for_all_symbols(i, sym) {
391: if (sym_has_value(sym) && !sym_is_choice_value(sym)) {
392: /* Reset values of generates values, so they'll appear
393: * as new, if they should become visible, but that
394: * doesn't quite work if the Kconfig and the saved
395: * configuration disagree.
396: */
397: if (sym->visible == no && !conf_unsaved)
398: sym->flags &= ~SYMBOL_DEF_USER;
399: switch (sym->type) {
400: case S_STRING:
401: case S_INT:
402: case S_HEX:
403: /* Reset a string value if it's out of range */
404: if (sym_string_within_range(sym, sym->def[S_DEF_USER].val))
405: break;
406: sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
407: conf_unsaved++;
408: break;
409: default:
410: break;
411: }
412: }
413: }
414:
415: sym_add_change_count(conf_warnings || conf_unsaved);
416:
417: return 0;
418: }
419:
420: /* Write a S_STRING */
421: static void conf_write_string(bool headerfile, const char *name,
422: const char *str, FILE *out)
423: {
424: int l;
425: if (headerfile)
426: fprintf(out, "#define %s%s \"", CONFIG_, name);
427: else
428: fprintf(out, "%s%s=\"", CONFIG_, name);
429:
430: while (1) {
431: l = strcspn(str, "\"\\");
432: if (l) {
433: xfwrite(str, l, 1, out);
434: str += l;
435: }
436: if (!*str)
437: break;
438: fprintf(out, "\\%c", *str++);
439: }
440: fputs("\"\n", out);
441: }
442:
443: static void conf_write_symbol(struct symbol *sym, FILE *out, bool write_no)
444: {
445: const char *str;
446:
447: switch (sym->type) {
448: case S_BOOLEAN:
449: case S_TRISTATE:
450: switch (sym_get_tristate_value(sym)) {
451: case no:
452: if (write_no)
453: fprintf(out, "# %s%s is not set\n",
454: CONFIG_, sym->name);
455: break;
456: case mod:
457: fprintf(out, "%s%s=m\n", CONFIG_, sym->name);
458: break;
459: case yes:
460: fprintf(out, "%s%s=y\n", CONFIG_, sym->name);
461: break;
462: }
463: break;
464: case S_STRING:
465: conf_write_string(false, sym->name, sym_get_string_value(sym), out);
466: break;
467: case S_HEX:
468: case S_INT:
469: str = sym_get_string_value(sym);
470: fprintf(out, "%s%s=%s\n", CONFIG_, sym->name, str);
471: break;
472: case S_OTHER:
473: case S_UNKNOWN:
474: break;
475: }
476: }
477:
478: /*
479: * Write out a minimal config.
480: * All values that has default values are skipped as this is redundant.
481: */
482: int conf_write_defconfig(const char *filename)
483: {
484: struct symbol *sym;
485: struct menu *menu;
486: FILE *out;
487:
488: out = fopen(filename, "w");
489: if (!out)
490: return 1;
491:
492: sym_clear_all_valid();
493:
494: /* Traverse all menus to find all relevant symbols */
495: menu = rootmenu.list;
496:
497: while (menu != NULL)
498: {
499: sym = menu->sym;
500: if (sym == NULL) {
501: if (!menu_is_visible(menu))
502: goto next_menu;
503: } else if (!sym_is_choice(sym)) {
504: sym_calc_value(sym);
505: if (!(sym->flags & SYMBOL_WRITE))
506: goto next_menu;
507: sym->flags &= ~SYMBOL_WRITE;
508: /* If we cannot change the symbol - skip */
509: if (!sym_is_changable(sym))
510: goto next_menu;
511: /* If symbol equals to default value - skip */
512: if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)
513: goto next_menu;
514:
515: /*
516: * If symbol is a choice value and equals to the
517: * default for a choice - skip.
518: * But only if value is bool and equal to "y" and
519: * choice is not "optional".
520: * (If choice is "optional" then all values can be "n")
521: */
522: if (sym_is_choice_value(sym)) {
523: struct symbol *cs;
524: struct symbol *ds;
525:
526: cs = prop_get_symbol(sym_get_choice_prop(sym));
527: ds = sym_choice_default(cs);
528: if (!sym_is_optional(cs) && sym == ds) {
529: if ((sym->type == S_BOOLEAN) &&
530: sym_get_tristate_value(sym) == yes)
531: goto next_menu;
532: }
533: }
534: conf_write_symbol(sym, out, true);
535: }
536: next_menu:
537: if (menu->list != NULL) {
538: menu = menu->list;
539: }
540: else if (menu->next != NULL) {
541: menu = menu->next;
542: } else {
543: while ((menu = menu->parent)) {
544: if (menu->next != NULL) {
545: menu = menu->next;
546: break;
547: }
548: }
549: }
550: }
551: fclose(out);
552: return 0;
553: }
554:
555: int conf_write(const char *name)
556: {
557: FILE *out;
558: struct symbol *sym;
559: struct menu *menu;
560: const char *basename;
561: const char *str;
562: char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1];
563: time_t now;
564: int use_timestamp = 1;
565: char *env;
566:
567: dirname[0] = 0;
568: if (name && name[0]) {
569: struct stat st;
570: char *slash;
571:
572: if (!stat(name, &st) && S_ISDIR(st.st_mode)) {
573: strcpy(dirname, name);
574: strcat(dirname, "/");
575: basename = conf_get_configname();
576: } else if ((slash = strrchr(name, '/'))) {
577: int size = slash - name + 1;
578: memcpy(dirname, name, size);
579: dirname[size] = 0;
580: if (slash[1])
581: basename = slash + 1;
582: else
583: basename = conf_get_configname();
584: } else
585: basename = name;
586: } else
587: basename = conf_get_configname();
588:
589: sprintf(newname, "%s%s", dirname, basename);
590: env = getenv("KCONFIG_OVERWRITECONFIG");
591: if (!env || !*env) {
592: sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
593: out = fopen(tmpname, "w");
594: } else {
595: *tmpname = 0;
596: out = fopen(newname, "w");
597: }
598: if (!out)
599: return 1;
600:
601: time(&now);
602: env = getenv("KCONFIG_NOTIMESTAMP");
603: if (env && *env)
604: use_timestamp = 0;
605:
606: fprintf(out, _("#\n"
607: "# Automatically generated make config: don't edit\n"
608: "# %s\n"
609: "%s%s"
610: "#\n"),
611: rootmenu.prompt->text,
612: use_timestamp ? "# " : "",
613: use_timestamp ? ctime(&now) : "");
614:
615: if (!conf_get_changed())
616: sym_clear_all_valid();
617:
618: menu = rootmenu.list;
619: while (menu) {
620: sym = menu->sym;
621: if (!sym) {
622: if (!menu_is_visible(menu))
623: goto next;
624: str = menu_get_prompt(menu);
625: fprintf(out, "\n"
626: "#\n"
627: "# %s\n"
628: "#\n", str);
629: } else if (!(sym->flags & SYMBOL_CHOICE)) {
630: sym_calc_value(sym);
631: if (!(sym->flags & SYMBOL_WRITE))
632: goto next;
633: sym->flags &= ~SYMBOL_WRITE;
634: /* Write config symbol to file */
635: conf_write_symbol(sym, out, true);
636: }
637:
638: next:
639: if (menu->list) {
640: menu = menu->list;
641: continue;
642: }
643: if (menu->next)
644: menu = menu->next;
645: else while ((menu = menu->parent)) {
646: if (menu->next) {
647: menu = menu->next;
648: break;
649: }
650: }
651: }
652: fclose(out);
653:
654: if (*tmpname) {
655: strcat(dirname, basename);
656: strcat(dirname, ".old");
657: rename(newname, dirname);
658: if (rename(tmpname, newname))
659: return 1;
660: }
661:
662: conf_message(_("configuration written to %s"), newname);
663:
664: sym_set_change_count(0);
665:
666: return 0;
667: }
668:
669: static int conf_split_config(void)
670: {
671: const char *name;
672: char path[PATH_MAX+1];
673: char *s, *d, c;
674: struct symbol *sym;
675: struct stat sb;
676: int res, i, fd;
677:
678: name = conf_get_autoconfig_name();
679: conf_read_simple(name, S_DEF_AUTO);
680:
681: if (chdir("include/config"))
682: return 1;
683:
684: res = 0;
685: for_all_symbols(i, sym) {
686: sym_calc_value(sym);
687: if ((sym->flags & SYMBOL_AUTO) || !sym->name)
688: continue;
689: if (sym->flags & SYMBOL_WRITE) {
690: if (sym->flags & SYMBOL_DEF_AUTO) {
691: /*
692: * symbol has old and new value,
693: * so compare them...
694: */
695: switch (sym->type) {
696: case S_BOOLEAN:
697: case S_TRISTATE:
698: if (sym_get_tristate_value(sym) ==
699: sym->def[S_DEF_AUTO].tri)
700: continue;
701: break;
702: case S_STRING:
703: case S_HEX:
704: case S_INT:
705: if (!strcmp(sym_get_string_value(sym),
706: sym->def[S_DEF_AUTO].val))
707: continue;
708: break;
709: default:
710: break;
711: }
712: } else {
713: /*
714: * If there is no old value, only 'no' (unset)
715: * is allowed as new value.
716: */
717: switch (sym->type) {
718: case S_BOOLEAN:
719: case S_TRISTATE:
720: if (sym_get_tristate_value(sym) == no)
721: continue;
722: break;
723: default:
724: break;
725: }
726: }
727: } else if (!(sym->flags & SYMBOL_DEF_AUTO))
728: /* There is neither an old nor a new value. */
729: continue;
730: /* else
731: * There is an old value, but no new value ('no' (unset)
732: * isn't saved in auto.conf, so the old value is always
733: * different from 'no').
734: */
735:
736: /* Replace all '_' and append ".h" */
737: s = sym->name;
738: d = path;
739: while ((c = *s++)) {
740: c = tolower(c);
741: *d++ = (c == '_') ? '/' : c;
742: }
743: strcpy(d, ".h");
744:
745: /* Assume directory path already exists. */
746: fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
747: if (fd == -1) {
748: if (errno != ENOENT) {
749: res = 1;
750: break;
751: }
752: /*
753: * Create directory components,
754: * unless they exist already.
755: */
756: d = path;
757: while ((d = strchr(d, '/'))) {
758: *d = 0;
759: if (stat(path, &sb) && mkdir(path, 0755)) {
760: res = 1;
761: goto out;
762: }
763: *d++ = '/';
764: }
765: /* Try it again. */
766: fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
767: if (fd == -1) {
768: res = 1;
769: break;
770: }
771: }
772: close(fd);
773: }
774: out:
775: if (chdir("../.."))
776: return 1;
777:
778: return res;
779: }
780:
781: int conf_write_autoconf(void)
782: {
783: struct symbol *sym;
784: const char *str;
785: const char *name;
786: FILE *out, *tristate, *out_h;
787: time_t now;
788: int i;
789:
790: sym_clear_all_valid();
791:
792: file_write_dep("include/config/auto.conf.cmd");
793:
794: if (conf_split_config())
795: return 1;
796:
797: out = fopen(".tmpconfig", "w");
798: if (!out)
799: return 1;
800:
801: tristate = fopen(".tmpconfig_tristate", "w");
802: if (!tristate) {
803: fclose(out);
804: return 1;
805: }
806:
807: out_h = fopen(".tmpconfig.h", "w");
808: if (!out_h) {
809: fclose(out);
810: fclose(tristate);
811: return 1;
812: }
813:
814: time(&now);
815: fprintf(out, "#\n"
816: "# Automatically generated make config: don't edit\n"
817: "# %s\n"
818: "# %s"
819: "#\n",
820: rootmenu.prompt->text, ctime(&now));
821: fprintf(tristate, "#\n"
822: "# Automatically generated - do not edit\n"
823: "\n");
824: fprintf(out_h, "/*\n"
825: " * Automatically generated C config: don't edit\n"
826: " * %s\n"
827: " * %s"
828: " */\n",
829: rootmenu.prompt->text, ctime(&now));
830:
831: for_all_symbols(i, sym) {
832: sym_calc_value(sym);
833: if (!sym->name)
834: continue;
835: if (!(sym->flags & SYMBOL_WRITE)) {
836: if (sym->type == S_BOOLEAN || sym->type == S_HEX
837: || sym->type == S_INT)
838: fprintf(out_h, "#define %s%s 0\n",
839: CONFIG_, sym->name);
840: continue;
841: }
842:
843: /* write symbol to config file */
844: conf_write_symbol(sym, out, false);
845:
846: /* update autoconf and tristate files */
847: switch (sym->type) {
848: case S_BOOLEAN:
849: case S_TRISTATE:
850: switch (sym_get_tristate_value(sym)) {
851: case no:
852: fprintf(out_h, "#define %s%s 0\n",
853: CONFIG_, sym->name);
854: break;
855: case mod:
856: fprintf(tristate, "%s%s=M\n",
857: CONFIG_, sym->name);
858: fprintf(out_h, "#define %s%s_MODULE 1\n",
859: CONFIG_, sym->name);
860: break;
861: case yes:
862: if (sym->type == S_TRISTATE)
863: fprintf(tristate,"%s%s=Y\n",
864: CONFIG_, sym->name);
865: fprintf(out_h, "#define %s%s 1\n",
866: CONFIG_, sym->name);
867: break;
868: }
869: break;
870: case S_STRING:
871: conf_write_string(true, sym->name, sym_get_string_value(sym), out_h);
872: break;
873: case S_HEX:
874: str = sym_get_string_value(sym);
875: if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
876: fprintf(out_h, "#define %s%s 0x%s\n",
877: CONFIG_, sym->name, str);
878: break;
879: }
880: case S_INT:
881: str = sym_get_string_value(sym);
882: fprintf(out_h, "#define %s%s %s\n",
883: CONFIG_, sym->name, str);
884: break;
885: default:
886: break;
887: }
888: }
889: fclose(out);
890: fclose(tristate);
891: fclose(out_h);
892:
893: name = getenv("KCONFIG_AUTOHEADER");
894: if (!name)
895: name = "include/generated/autoconf.h";
896: if (rename(".tmpconfig.h", name))
897: return 1;
898: name = getenv("KCONFIG_TRISTATE");
899: if (!name)
900: name = "include/config/tristate.conf";
901: if (rename(".tmpconfig_tristate", name))
902: return 1;
903: name = conf_get_autoconfig_name();
904: /*
905: * This must be the last step, kbuild has a dependency on auto.conf
906: * and this marks the successful completion of the previous steps.
907: */
908: if (rename(".tmpconfig", name))
909: return 1;
910:
911: return 0;
912: }
913:
914: static int sym_change_count;
915: static void (*conf_changed_callback)(void);
916:
917: void sym_set_change_count(int count)
918: {
919: int _sym_change_count = sym_change_count;
920: sym_change_count = count;
921: if (conf_changed_callback &&
922: (bool)_sym_change_count != (bool)count)
923: conf_changed_callback();
924: }
925:
926: void sym_add_change_count(int count)
927: {
928: sym_set_change_count(count + sym_change_count);
929: }
930:
931: bool conf_get_changed(void)
932: {
933: return sym_change_count;
934: }
935:
936: void conf_set_changed_callback(void (*fn)(void))
937: {
938: conf_changed_callback = fn;
939: }
940:
941: static void randomize_choice_values(struct symbol *csym)
942: {
943: struct property *prop;
944: struct symbol *sym;
945: struct expr *e;
946: int cnt, def;
947:
948: /*
949: * If choice is mod then we may have more items selected
950: * and if no then no-one.
951: * In both cases stop.
952: */
953: if (csym->curr.tri != yes)
954: return;
955:
956: prop = sym_get_choice_prop(csym);
957:
958: /* count entries in choice block */
959: cnt = 0;
960: expr_list_for_each_sym(prop->expr, e, sym)
961: cnt++;
962:
963: /*
964: * find a random value and set it to yes,
965: * set the rest to no so we have only one set
966: */
967: def = (rand() % cnt);
968:
969: cnt = 0;
970: expr_list_for_each_sym(prop->expr, e, sym) {
971: if (def == cnt++) {
972: sym->def[S_DEF_USER].tri = yes;
973: csym->def[S_DEF_USER].val = sym;
974: }
975: else {
976: sym->def[S_DEF_USER].tri = no;
977: }
978: }
979: csym->flags |= SYMBOL_DEF_USER;
980: /* clear VALID to get value calculated */
981: csym->flags &= ~(SYMBOL_VALID);
982: }
983:
984: static void set_all_choice_values(struct symbol *csym)
985: {
986: struct property *prop;
987: struct symbol *sym;
988: struct expr *e;
989:
990: prop = sym_get_choice_prop(csym);
991:
992: /*
993: * Set all non-assinged choice values to no
994: */
995: expr_list_for_each_sym(prop->expr, e, sym) {
996: if (!sym_has_value(sym))
997: sym->def[S_DEF_USER].tri = no;
998: }
999: csym->flags |= SYMBOL_DEF_USER;
1000: /* clear VALID to get value calculated */
1001: csym->flags &= ~(SYMBOL_VALID);
1002: }
1003:
1004: void conf_set_all_new_symbols(enum conf_def_mode mode)
1005: {
1006: struct symbol *sym, *csym;
1007: int i, cnt;
1008:
1009: for_all_symbols(i, sym) {
1010: if (sym_has_value(sym))
1011: continue;
1012: switch (sym_get_type(sym)) {
1013: case S_BOOLEAN:
1014: case S_TRISTATE:
1015: switch (mode) {
1016: case def_yes:
1017: sym->def[S_DEF_USER].tri = yes;
1018: break;
1019: case def_mod:
1020: sym->def[S_DEF_USER].tri = mod;
1021: break;
1022: case def_no:
1023: sym->def[S_DEF_USER].tri = no;
1024: break;
1025: case def_random:
1026: cnt = sym_get_type(sym) == S_TRISTATE ? 3 : 2;
1027: sym->def[S_DEF_USER].tri = (tristate)(rand() % cnt);
1028: break;
1029: default:
1030: continue;
1031: }
1032: if (!(sym_is_choice(sym) && mode == def_random))
1033: sym->flags |= SYMBOL_DEF_USER;
1034: break;
1035: default:
1036: break;
1037: }
1038:
1039: }
1040:
1041: sym_clear_all_valid();
1042:
1043: /*
1044: * We have different type of choice blocks.
1045: * If curr.tri equals to mod then we can select several
1046: * choice symbols in one block.
1047: * In this case we do nothing.
1048: * If curr.tri equals yes then only one symbol can be
1049: * selected in a choice block and we set it to yes,
1050: * and the rest to no.
1051: */
1052: for_all_symbols(i, csym) {
1053: if (sym_has_value(csym) || !sym_is_choice(csym))
1054: continue;
1055:
1056: sym_calc_value(csym);
1057: if (mode == def_random)
1058: randomize_choice_values(csym);
1059: else
1060: set_all_choice_values(csym);
1061: }
1062: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.