scripts/addToolsVersion: properly handle .in vs. .in.2
While most components have their version in the .in file, some
have it in the .in.2 (eg. elf2flt).
Currently, to handle this case, we indiscriminately munge both files,
but this is wrong: in the elf2flt case, if we add a binutils version,
we do not want it to be added to elf2flt, and conversely.
So, for each tool, we need to explicitly know what file to munge.
Signed-off-by: "Yann E. MORIN" <yann.morin.1998@free.fr>
2 * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
3 * Released under the terms of the GNU GPL v2.0.
16 #define LKC_DIRECT_LINK
19 static void conf_warning(const char *fmt, ...)
20 __attribute__ ((format (printf, 1, 2)));
22 static void conf_message(const char *fmt, ...)
23 __attribute__ ((format (printf, 1, 2)));
25 static const char *conf_filename;
26 static int conf_lineno, conf_warnings, conf_unsaved;
28 const char conf_defname[] = "arch/$ARCH/defconfig";
30 static void conf_warning(const char *fmt, ...)
34 fprintf(stderr, "%s:%d:warning: ", conf_filename, conf_lineno);
35 vfprintf(stderr, fmt, ap);
36 fprintf(stderr, "\n");
41 static void conf_default_message_callback(const char *fmt, va_list ap)
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))
52 conf_message_callback = fn;
55 static void conf_message(const char *fmt, ...)
60 if (conf_message_callback)
61 conf_message_callback(fmt, ap);
64 const char *conf_get_configname(void)
66 char *name = getenv("KCONFIG_CONFIG");
68 return name ? name : ".config";
71 const char *conf_get_autoconfig_name(void)
73 char *name = getenv("KCONFIG_AUTOCONFIG");
75 return name ? name : "include/config/auto.conf";
78 static char *conf_expand_value(const char *in)
82 static char res_value[SYMBOL_MAXLENGTH];
83 char *dst, name[SYMBOL_MAXLENGTH];
87 while ((src = strchr(in, '$'))) {
88 strncat(res_value, in, src - in);
91 while (isalnum(*src) || *src == '_')
94 sym = sym_lookup(name, 0);
96 strcat(res_value, sym_get_string_value(sym));
99 strcat(res_value, in);
104 char *conf_get_default_confname(void)
107 static char fullname[PATH_MAX+1];
110 name = conf_expand_value(conf_defname);
111 env = getenv(SRCTREE);
113 sprintf(fullname, "%s/%s", env, name);
114 if (!stat(fullname, &buf))
120 static int conf_set_sym_val(struct symbol *sym, int def, int def_flags, char *p)
127 sym->def[def].tri = mod;
128 sym->flags |= def_flags;
133 sym->def[def].tri = yes;
134 sym->flags |= def_flags;
138 sym->def[def].tri = no;
139 sym->flags |= def_flags;
142 conf_warning("symbol value '%s' invalid for %s", p, sym->name);
146 for (p2 = p; *p2 && !isspace(*p2); p2++)
148 sym->type = S_STRING;
154 for (p2 = p; (p2 = strpbrk(p2, "\"\\")); p2++) {
159 memmove(p2, p2 + 1, strlen(p2));
162 conf_warning("invalid string found");
168 if (sym_string_valid(sym, p)) {
169 sym->def[def].val = strdup(p);
170 sym->flags |= def_flags;
172 conf_warning("symbol value '%s' invalid for %s", p, sym->name);
182 int conf_read_simple(const char *name, int def)
191 in = zconf_fopen(name);
193 struct property *prop;
195 name = conf_get_configname();
196 in = zconf_fopen(name);
199 sym_add_change_count(1);
200 if (!sym_defconfig_list) {
202 sym_calc_value(modules_sym);
206 for_all_defaults(sym_defconfig_list, prop) {
207 if (expr_calc_value(prop->visible.expr) == no ||
208 prop->expr->type != E_SYMBOL)
210 name = conf_expand_value(prop->expr->left.sym->name);
211 in = zconf_fopen(name);
213 conf_message(_("using defaults found in %s"),
223 conf_filename = name;
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;
238 if (sym->def[def].val)
239 free(sym->def[def].val);
241 sym->def[def].val = NULL;
242 sym->def[def].tri = no;
246 while (fgets(line, sizeof(line), in)) {
249 if (line[0] == '#') {
250 if (memcmp(line + 2, CONFIG_, strlen(CONFIG_)))
252 p = strchr(line + 2 + strlen(CONFIG_), ' ');
256 if (strncmp(p, "is not set", 10))
258 if (def == S_DEF_USER) {
259 sym = sym_find(line + 2 + strlen(CONFIG_));
261 sym_add_change_count(1);
265 sym = sym_lookup(line + 2 + strlen(CONFIG_), 0);
266 if (sym->type == S_UNKNOWN)
267 sym->type = S_BOOLEAN;
269 if (sym->flags & def_flags) {
270 conf_warning("override: reassigning to symbol %s", sym->name);
275 sym->def[def].tri = no;
276 sym->flags |= def_flags;
281 } else if (memcmp(line, CONFIG_, strlen(CONFIG_)) == 0) {
282 p = strchr(line + strlen(CONFIG_), '=');
286 p2 = strchr(p, '\n');
292 if (def == S_DEF_USER) {
293 sym = sym_find(line + strlen(CONFIG_));
295 sym_add_change_count(1);
299 sym = sym_lookup(line + strlen(CONFIG_), 0);
300 if (sym->type == S_UNKNOWN)
303 if (sym->flags & def_flags) {
304 conf_warning("override: reassigning to symbol %s", sym->name);
306 if (conf_set_sym_val(sym, def, def_flags, p))
309 if (line[0] != '\r' && line[0] != '\n')
310 conf_warning("unexpected data");
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) {
320 if (cs->def[def].tri == yes) {
321 conf_warning("%s creates inconsistent choice state", sym->name);
322 cs->flags &= ~def_flags;
326 if (cs->def[def].tri != no)
327 conf_warning("override: %s changes choice state", sym->name);
328 cs->def[def].val = sym;
331 cs->def[def].tri = EXPR_OR(cs->def[def].tri, sym->def[def].tri);
337 sym_calc_value(modules_sym);
341 int conf_read(const char *name)
343 struct symbol *sym, *choice_sym;
344 struct property *prop;
348 sym_set_change_count(0);
350 if (conf_read_simple(name, S_DEF_USER))
353 for_all_symbols(i, sym) {
355 if (sym_is_choice(sym) || (sym->flags & SYMBOL_AUTO))
357 if (sym_has_value(sym) && (sym->flags & SYMBOL_WRITE)) {
358 /* check that calculated value agrees with saved value */
362 if (sym->def[S_DEF_USER].tri != sym_get_tristate_value(sym))
364 if (!sym_is_choice(sym))
367 if (!strcmp(sym->curr.val, sym->def[S_DEF_USER].val))
371 } else if (!sym_has_value(sym) && !(sym->flags & SYMBOL_WRITE))
372 /* no previous value and not saved */
375 /* maybe print value in verbose mode... */
377 if (!sym_is_choice(sym))
379 /* The choice symbol only has a set value (and thus is not new)
380 * if all its visible childs have values.
382 prop = sym_get_choice_prop(sym);
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;
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.
397 if (sym->visible == no && !conf_unsaved)
398 sym->flags &= ~SYMBOL_DEF_USER;
403 /* Reset a string value if it's out of range */
404 if (sym_string_within_range(sym, sym->def[S_DEF_USER].val))
406 sym->flags &= ~(SYMBOL_VALID|SYMBOL_DEF_USER);
415 sym_add_change_count(conf_warnings || conf_unsaved);
420 /* Write a S_STRING */
421 static void conf_write_string(bool headerfile, const char *name,
422 const char *str, FILE *out)
426 fprintf(out, "#define %s%s \"", CONFIG_, name);
428 fprintf(out, "%s%s=\"", CONFIG_, name);
431 l = strcspn(str, "\"\\");
433 xfwrite(str, l, 1, out);
438 fprintf(out, "\\%c", *str++);
443 static void conf_write_symbol(struct symbol *sym, FILE *out, bool write_no)
450 switch (sym_get_tristate_value(sym)) {
453 fprintf(out, "# %s%s is not set\n",
457 fprintf(out, "%s%s=m\n", CONFIG_, sym->name);
460 fprintf(out, "%s%s=y\n", CONFIG_, sym->name);
465 conf_write_string(false, sym->name, sym_get_string_value(sym), out);
469 str = sym_get_string_value(sym);
470 fprintf(out, "%s%s=%s\n", CONFIG_, sym->name, str);
479 * Write out a minimal config.
480 * All values that has default values are skipped as this is redundant.
482 int conf_write_defconfig(const char *filename)
488 out = fopen(filename, "w");
492 sym_clear_all_valid();
494 /* Traverse all menus to find all relevant symbols */
495 menu = rootmenu.list;
501 if (!menu_is_visible(menu))
503 } else if (!sym_is_choice(sym)) {
505 if (!(sym->flags & SYMBOL_WRITE))
507 sym->flags &= ~SYMBOL_WRITE;
508 /* If we cannot change the symbol - skip */
509 if (!sym_is_changable(sym))
511 /* If symbol equals to default value - skip */
512 if (strcmp(sym_get_string_value(sym), sym_get_string_default(sym)) == 0)
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")
522 if (sym_is_choice_value(sym)) {
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)
534 conf_write_symbol(sym, out, true);
537 if (menu->list != NULL) {
540 else if (menu->next != NULL) {
543 while ((menu = menu->parent)) {
544 if (menu->next != NULL) {
555 int conf_write(const char *name)
560 const char *basename;
562 char dirname[PATH_MAX+1], tmpname[PATH_MAX+1], newname[PATH_MAX+1];
564 int use_timestamp = 1;
568 if (name && name[0]) {
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);
581 basename = slash + 1;
583 basename = conf_get_configname();
587 basename = conf_get_configname();
589 sprintf(newname, "%s%s", dirname, basename);
590 env = getenv("KCONFIG_OVERWRITECONFIG");
592 sprintf(tmpname, "%s.tmpconfig.%d", dirname, (int)getpid());
593 out = fopen(tmpname, "w");
596 out = fopen(newname, "w");
602 env = getenv("KCONFIG_NOTIMESTAMP");
607 "# Automatically generated make config: don't edit\n"
611 rootmenu.prompt->text,
612 use_timestamp ? "# " : "",
613 use_timestamp ? ctime(&now) : "");
615 if (!conf_get_changed())
616 sym_clear_all_valid();
618 menu = rootmenu.list;
622 if (!menu_is_visible(menu))
624 str = menu_get_prompt(menu);
629 } else if (!(sym->flags & SYMBOL_CHOICE)) {
631 if (!(sym->flags & SYMBOL_WRITE))
633 sym->flags &= ~SYMBOL_WRITE;
634 /* Write config symbol to file */
635 conf_write_symbol(sym, out, true);
645 else while ((menu = menu->parent)) {
655 strcat(dirname, basename);
656 strcat(dirname, ".old");
657 rename(newname, dirname);
658 if (rename(tmpname, newname))
662 conf_message(_("configuration saved"));
664 sym_set_change_count(0);
669 static int conf_split_config(void)
672 char path[PATH_MAX+1];
678 name = conf_get_autoconfig_name();
679 conf_read_simple(name, S_DEF_AUTO);
681 if (chdir("include/config"))
685 for_all_symbols(i, sym) {
687 if ((sym->flags & SYMBOL_AUTO) || !sym->name)
689 if (sym->flags & SYMBOL_WRITE) {
690 if (sym->flags & SYMBOL_DEF_AUTO) {
692 * symbol has old and new value,
698 if (sym_get_tristate_value(sym) ==
699 sym->def[S_DEF_AUTO].tri)
705 if (!strcmp(sym_get_string_value(sym),
706 sym->def[S_DEF_AUTO].val))
714 * If there is no old value, only 'no' (unset)
715 * is allowed as new value.
720 if (sym_get_tristate_value(sym) == no)
727 } else if (!(sym->flags & SYMBOL_DEF_AUTO))
728 /* There is neither an old nor a new value. */
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').
736 /* Replace all '_' and append ".h" */
741 *d++ = (c == '_') ? '/' : c;
745 /* Assume directory path already exists. */
746 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
748 if (errno != ENOENT) {
753 * Create directory components,
754 * unless they exist already.
757 while ((d = strchr(d, '/'))) {
759 if (stat(path, &sb) && mkdir(path, 0755)) {
766 fd = open(path, O_WRONLY | O_CREAT | O_TRUNC, 0644);
781 int conf_write_autoconf(void)
786 FILE *out, *tristate, *out_h;
789 sym_clear_all_valid();
791 file_write_dep("include/config/auto.conf.cmd");
793 if (conf_split_config())
796 out = fopen(".tmpconfig", "w");
800 tristate = fopen(".tmpconfig_tristate", "w");
806 out_h = fopen(".tmpconfig.h", "w");
814 "# Automatically generated make config: don't edit\n"
817 rootmenu.prompt->text);
818 fprintf(tristate, "#\n"
819 "# Automatically generated - do not edit\n"
821 fprintf(out_h, "/*\n"
822 " * Automatically generated C config: don't edit\n"
825 rootmenu.prompt->text);
827 for_all_symbols(i, sym) {
829 if (!(sym->flags & SYMBOL_WRITE) || !sym->name)
832 /* write symbol to config file */
833 conf_write_symbol(sym, out, false);
835 /* update autoconf and tristate files */
839 switch (sym_get_tristate_value(sym)) {
843 fprintf(tristate, "%s%s=M\n",
845 fprintf(out_h, "#define %s%s_MODULE 1\n",
849 if (sym->type == S_TRISTATE)
850 fprintf(tristate,"%s%s=Y\n",
852 fprintf(out_h, "#define %s%s 1\n",
858 conf_write_string(true, sym->name, sym_get_string_value(sym), out_h);
861 str = sym_get_string_value(sym);
862 if (str[0] != '0' || (str[1] != 'x' && str[1] != 'X')) {
863 fprintf(out_h, "#define %s%s 0x%s\n",
864 CONFIG_, sym->name, str);
868 str = sym_get_string_value(sym);
869 fprintf(out_h, "#define %s%s %s\n",
870 CONFIG_, sym->name, str);
880 name = getenv("KCONFIG_AUTOHEADER");
882 name = "include/generated/autoconf.h";
883 if (rename(".tmpconfig.h", name))
885 name = getenv("KCONFIG_TRISTATE");
887 name = "include/config/tristate.conf";
888 if (rename(".tmpconfig_tristate", name))
890 name = conf_get_autoconfig_name();
892 * This must be the last step, kbuild has a dependency on auto.conf
893 * and this marks the successful completion of the previous steps.
895 if (rename(".tmpconfig", name))
901 static int sym_change_count;
902 static void (*conf_changed_callback)(void);
904 void sym_set_change_count(int count)
906 int _sym_change_count = sym_change_count;
907 sym_change_count = count;
908 if (conf_changed_callback &&
909 (bool)_sym_change_count != (bool)count)
910 conf_changed_callback();
913 void sym_add_change_count(int count)
915 sym_set_change_count(count + sym_change_count);
918 bool conf_get_changed(void)
920 return sym_change_count;
923 void conf_set_changed_callback(void (*fn)(void))
925 conf_changed_callback = fn;
928 static void randomize_choice_values(struct symbol *csym)
930 struct property *prop;
936 * If choice is mod then we may have more items selected
937 * and if no then no-one.
938 * In both cases stop.
940 if (csym->curr.tri != yes)
943 prop = sym_get_choice_prop(csym);
945 /* count entries in choice block */
947 expr_list_for_each_sym(prop->expr, e, sym)
951 * find a random value and set it to yes,
952 * set the rest to no so we have only one set
954 def = (rand() % cnt);
957 expr_list_for_each_sym(prop->expr, e, sym) {
959 sym->def[S_DEF_USER].tri = yes;
960 csym->def[S_DEF_USER].val = sym;
963 sym->def[S_DEF_USER].tri = no;
966 csym->flags |= SYMBOL_DEF_USER;
967 /* clear VALID to get value calculated */
968 csym->flags &= ~(SYMBOL_VALID);
971 static void set_all_choice_values(struct symbol *csym)
973 struct property *prop;
977 prop = sym_get_choice_prop(csym);
980 * Set all non-assinged choice values to no
982 expr_list_for_each_sym(prop->expr, e, sym) {
983 if (!sym_has_value(sym))
984 sym->def[S_DEF_USER].tri = no;
986 csym->flags |= SYMBOL_DEF_USER;
987 /* clear VALID to get value calculated */
988 csym->flags &= ~(SYMBOL_VALID);
991 void conf_set_all_new_symbols(enum conf_def_mode mode)
993 struct symbol *sym, *csym;
996 for_all_symbols(i, sym) {
997 if (sym_has_value(sym))
999 switch (sym_get_type(sym)) {
1004 sym->def[S_DEF_USER].tri = yes;
1007 sym->def[S_DEF_USER].tri = mod;
1010 sym->def[S_DEF_USER].tri = no;
1013 cnt = sym_get_type(sym) == S_TRISTATE ? 3 : 2;
1014 sym->def[S_DEF_USER].tri = (tristate)(rand() % cnt);
1019 if (!(sym_is_choice(sym) && mode == def_random))
1020 sym->flags |= SYMBOL_DEF_USER;
1028 sym_clear_all_valid();
1031 * We have different type of choice blocks.
1032 * If curr.tri equals to mod then we can select several
1033 * choice symbols in one block.
1034 * In this case we do nothing.
1035 * If curr.tri equals yes then only one symbol can be
1036 * selected in a choice block and we set it to yes,
1037 * and the rest to no.
1039 for_all_symbols(i, csym) {
1040 if (sym_has_value(csym) || !sym_is_choice(csym))
1043 sym_calc_value(csym);
1044 if (mode == def_random)
1045 randomize_choice_values(csym);
1047 set_all_choice_values(csym);