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.
9 #define LKC_DIRECT_LINK
12 static const char nohelp_text[] = N_(
13 "There is no help available for this option.\n");
16 static struct menu **last_entry_ptr;
18 struct file *file_list;
19 struct file *current_file;
21 void menu_warn(struct menu *menu, const char *fmt, ...)
25 fprintf(stderr, "%s:%d:warning: ", menu->file->name, menu->lineno);
26 vfprintf(stderr, fmt, ap);
27 fprintf(stderr, "\n");
31 static void prop_warn(struct property *prop, const char *fmt, ...)
35 fprintf(stderr, "%s:%d:warning: ", prop->file->name, prop->lineno);
36 vfprintf(stderr, fmt, ap);
37 fprintf(stderr, "\n");
43 current_entry = current_menu = &rootmenu;
44 last_entry_ptr = &rootmenu.list;
47 void menu_add_entry(struct symbol *sym)
51 menu = malloc(sizeof(*menu));
52 memset(menu, 0, sizeof(*menu));
54 menu->parent = current_menu;
55 menu->file = current_file;
56 menu->lineno = zconf_lineno();
58 *last_entry_ptr = menu;
59 last_entry_ptr = &menu->next;
62 menu_add_symbol(P_SYMBOL, sym, NULL);
65 void menu_end_entry(void)
69 struct menu *menu_add_menu(void)
72 last_entry_ptr = ¤t_entry->list;
73 return current_menu = current_entry;
76 void menu_end_menu(void)
78 last_entry_ptr = ¤t_menu->next;
79 current_menu = current_menu->parent;
82 static struct expr *menu_check_dep(struct expr *e)
89 e->left.expr = menu_check_dep(e->left.expr);
93 e->left.expr = menu_check_dep(e->left.expr);
94 e->right.expr = menu_check_dep(e->right.expr);
97 /* change 'm' into 'm' && MODULES */
98 if (e->left.sym == &symbol_mod)
99 return expr_alloc_and(e, expr_alloc_symbol(modules_sym));
107 void menu_add_dep(struct expr *dep)
109 current_entry->dep = expr_alloc_and(current_entry->dep, menu_check_dep(dep));
112 void menu_set_type(int type)
114 struct symbol *sym = current_entry->sym;
116 if (sym->type == type)
118 if (sym->type == S_UNKNOWN) {
122 menu_warn(current_entry, "type of '%s' redefined from '%s' to '%s'",
123 sym->name ? sym->name : "<choice>",
124 sym_type_name(sym->type), sym_type_name(type));
127 struct property *menu_add_prop(enum prop_type type, char *prompt, struct expr *expr, struct expr *dep)
129 struct property *prop = prop_alloc(type, current_entry->sym);
131 prop->menu = current_entry;
133 prop->visible.expr = menu_check_dep(dep);
136 /* For crostool-NG, a leading pipe followed with spaces
137 * means that pipe shall be removed, and the spaces should
142 else if (isspace(*prompt)) {
143 prop_warn(prop, "leading whitespace ignored");
144 while (isspace(*prompt))
147 if (current_entry->prompt && current_entry != &rootmenu)
148 prop_warn(prop, "prompt redefined");
150 /* Apply all upper menus' visibilities to actual prompts. */
151 if(type == P_PROMPT) {
152 struct menu *menu = current_entry;
154 while ((menu = menu->parent) != NULL) {
155 if (!menu->visibility)
158 = expr_alloc_and(prop->visible.expr,
163 current_entry->prompt = prop;
170 struct property *menu_add_prompt(enum prop_type type, char *prompt, struct expr *dep)
172 return menu_add_prop(type, prompt, NULL, dep);
175 void menu_add_visibility(struct expr *expr)
177 current_entry->visibility = expr_alloc_and(current_entry->visibility,
181 void menu_add_expr(enum prop_type type, struct expr *expr, struct expr *dep)
183 menu_add_prop(type, NULL, expr, dep);
186 void menu_add_symbol(enum prop_type type, struct symbol *sym, struct expr *dep)
188 menu_add_prop(type, NULL, expr_alloc_symbol(sym), dep);
191 void menu_add_option(int token, char *arg)
193 struct property *prop;
197 prop = prop_alloc(P_DEFAULT, modules_sym);
198 prop->expr = expr_alloc_symbol(current_entry->sym);
200 case T_OPT_DEFCONFIG_LIST:
201 if (!sym_defconfig_list)
202 sym_defconfig_list = current_entry->sym;
203 else if (sym_defconfig_list != current_entry->sym)
204 zconf_error("trying to redefine defconfig symbol");
212 static int menu_validate_number(struct symbol *sym, struct symbol *sym2)
214 return sym2->type == S_INT || sym2->type == S_HEX ||
215 (sym2->type == S_UNKNOWN && sym_string_valid(sym, sym2->name));
218 static void sym_check_prop(struct symbol *sym)
220 struct property *prop;
222 for (prop = sym->prop; prop; prop = prop->next) {
223 switch (prop->type) {
225 if ((sym->type == S_STRING || sym->type == S_INT || sym->type == S_HEX) &&
226 prop->expr->type != E_SYMBOL)
228 "default for config symbol '%s'"
229 " must be a single symbol", sym->name);
230 if (prop->expr->type != E_SYMBOL)
232 sym2 = prop_get_symbol(prop);
233 if (sym->type == S_HEX || sym->type == S_INT) {
234 if (!menu_validate_number(sym, sym2))
236 "'%s': number is invalid",
241 sym2 = prop_get_symbol(prop);
242 if (sym->type != S_BOOLEAN && sym->type != S_TRISTATE)
244 "config symbol '%s' uses select, but is "
245 "not boolean or tristate", sym->name);
246 else if (sym2->type != S_UNKNOWN &&
247 sym2->type != S_BOOLEAN &&
248 sym2->type != S_TRISTATE)
250 "'%s' has wrong type. 'select' only "
251 "accept arguments of boolean and "
252 "tristate type", sym2->name);
255 if (sym->type != S_INT && sym->type != S_HEX)
256 prop_warn(prop, "range is only allowed "
257 "for int or hex symbols");
258 if (!menu_validate_number(sym, prop->expr->left.sym) ||
259 !menu_validate_number(sym, prop->expr->right.sym))
260 prop_warn(prop, "range is invalid");
268 void menu_finalize(struct menu *parent)
270 struct menu *menu, *last_menu;
272 struct property *prop;
273 struct expr *parentdep, *basedep, *dep, *dep2, **ep;
277 if (sym && sym_is_choice(sym)) {
278 if (sym->type == S_UNKNOWN) {
279 /* find the first choice value to find out choice type */
280 current_entry = parent;
281 for (menu = parent->list; menu; menu = menu->next) {
282 if (menu->sym && menu->sym->type != S_UNKNOWN) {
283 menu_set_type(menu->sym->type);
288 if (parent->prompt &&
289 !expr_is_yes(parent->prompt->visible.expr)) {
290 parent->visibility = expr_alloc_and (parent->visibility,
291 parent->prompt->visible.expr);
293 /* set the type of the remaining choice values */
294 for (menu = parent->list; menu; menu = menu->next) {
295 current_entry = menu;
296 if (menu->sym && menu->sym->type == S_UNKNOWN)
297 menu_set_type(sym->type);
299 parentdep = expr_alloc_symbol(sym);
300 } else if (parent->prompt)
301 parentdep = parent->prompt->visible.expr;
303 parentdep = parent->dep;
305 for (menu = parent->list; menu; menu = menu->next) {
306 basedep = expr_transform(menu->dep);
307 basedep = expr_alloc_and(expr_copy(parentdep), basedep);
308 basedep = expr_eliminate_dups(basedep);
311 prop = menu->sym->prop;
314 for (; prop; prop = prop->next) {
315 if (prop->menu != menu)
317 dep = expr_transform(prop->visible.expr);
318 dep = expr_alloc_and(expr_copy(basedep), dep);
319 dep = expr_eliminate_dups(dep);
320 if (menu->sym && menu->sym->type != S_TRISTATE)
321 dep = expr_trans_bool(dep);
322 prop->visible.expr = dep;
323 if (prop->type == P_SELECT) {
324 struct symbol *es = prop_get_symbol(prop);
325 es->rev_dep.expr = expr_alloc_or(es->rev_dep.expr,
326 expr_alloc_and(expr_alloc_symbol(menu->sym), expr_copy(dep)));
330 for (menu = parent->list; menu; menu = menu->next)
333 basedep = parent->prompt ? parent->prompt->visible.expr : NULL;
334 basedep = expr_trans_compare(basedep, E_UNEQUAL, &symbol_no);
335 basedep = expr_eliminate_dups(expr_transform(basedep));
337 for (menu = parent->next; menu; menu = menu->next) {
338 dep = menu->prompt ? menu->prompt->visible.expr : menu->dep;
339 if (!expr_contains_symbol(dep, sym))
341 if (expr_depends_symbol(dep, sym))
343 dep = expr_trans_compare(dep, E_UNEQUAL, &symbol_no);
344 dep = expr_eliminate_dups(expr_transform(dep));
345 dep2 = expr_copy(basedep);
346 expr_eliminate_eq(&dep, &dep2);
348 if (!expr_is_yes(dep2)) {
355 menu->parent = parent;
359 parent->list = parent->next;
360 parent->next = last_menu->next;
361 last_menu->next = NULL;
364 sym->dir_dep.expr = expr_alloc_or(sym->dir_dep.expr, parent->dep);
366 for (menu = parent->list; menu; menu = menu->next) {
367 if (sym && sym_is_choice(sym) &&
368 menu->sym && !sym_is_choice_value(menu->sym)) {
369 current_entry = menu;
370 menu->sym->flags |= SYMBOL_CHOICEVAL;
372 menu_warn(menu, "choice value must have a prompt");
373 for (prop = menu->sym->prop; prop; prop = prop->next) {
374 if (prop->type == P_DEFAULT)
375 prop_warn(prop, "defaults for choice "
376 "values not supported");
377 if (prop->menu == menu)
379 if (prop->type == P_PROMPT &&
380 prop->menu->parent->sym != sym)
381 prop_warn(prop, "choice value used outside its choice group");
383 /* Non-tristate choice values of tristate choices must
384 * depend on the choice being set to Y. The choice
385 * values' dependencies were propagated to their
386 * properties above, so the change here must be re-
389 if (sym->type == S_TRISTATE && menu->sym->type != S_TRISTATE) {
390 basedep = expr_alloc_comp(E_EQUAL, sym, &symbol_yes);
391 menu->dep = expr_alloc_and(basedep, menu->dep);
392 for (prop = menu->sym->prop; prop; prop = prop->next) {
393 if (prop->menu != menu)
395 prop->visible.expr = expr_alloc_and(expr_copy(basedep),
399 menu_add_symbol(P_CHOICE, sym, NULL);
400 prop = sym_get_choice_prop(sym);
401 for (ep = &prop->expr; *ep; ep = &(*ep)->left.expr)
403 *ep = expr_alloc_one(E_LIST, NULL);
404 (*ep)->right.sym = menu->sym;
406 if (menu->list && (!menu->prompt || !menu->prompt->text)) {
407 for (last_menu = menu->list; ; last_menu = last_menu->next) {
408 last_menu->parent = parent;
409 if (!last_menu->next)
412 last_menu->next = menu->next;
413 menu->next = menu->list;
418 if (sym && !(sym->flags & SYMBOL_WARNED)) {
419 if (sym->type == S_UNKNOWN)
420 menu_warn(parent, "config symbol defined without type");
422 if (sym_is_choice(sym) && !parent->prompt)
423 menu_warn(parent, "choice must have a prompt");
425 /* Check properties connected to this symbol */
427 sym->flags |= SYMBOL_WARNED;
430 if (sym && !sym_is_optional(sym) && parent->prompt) {
431 sym->rev_dep.expr = expr_alloc_or(sym->rev_dep.expr,
432 expr_alloc_and(parent->prompt->visible.expr,
433 expr_alloc_symbol(&symbol_mod)));
437 bool menu_has_prompt(struct menu *menu)
444 bool menu_is_visible(struct menu *menu)
453 if (menu->visibility) {
454 if (expr_calc_value(menu->visibility) == no)
461 visible = menu->prompt->visible.tri;
463 visible = menu->prompt->visible.tri = expr_calc_value(menu->prompt->visible.expr);
468 if (!sym || sym_get_tristate_value(menu->sym) == no)
471 for (child = menu->list; child; child = child->next) {
472 if (menu_is_visible(child)) {
474 sym->flags |= SYMBOL_DEF_USER;
482 const char *menu_get_prompt(struct menu *menu)
485 return menu->prompt->text;
487 return menu->sym->name;
491 struct menu *menu_get_root_menu(struct menu *menu)
496 struct menu *menu_get_parent_menu(struct menu *menu)
500 for (; menu != &rootmenu; menu = menu->parent) {
501 type = menu->prompt ? menu->prompt->type : 0;
508 bool menu_has_help(struct menu *menu)
510 return menu->help != NULL;
513 const char *menu_get_help(struct menu *menu)
521 static void get_prompt_str(struct gstr *r, struct property *prop)
524 struct menu *submenu[8], *menu;
526 str_printf(r, _("Prompt: %s\n"), _(prop->text));
527 str_printf(r, _(" Defined at %s:%d\n"), prop->menu->file->name,
529 if (!expr_is_yes(prop->visible.expr)) {
530 str_append(r, _(" Depends on: "));
531 expr_gstr_print(prop->visible.expr, r);
534 menu = prop->menu->parent;
535 for (i = 0; menu != &rootmenu && i < 8; menu = menu->parent)
538 str_printf(r, _(" Location:\n"));
539 for (j = 4; --i >= 0; j += 2) {
541 str_printf(r, "%*c-> %s", j, ' ', _(menu_get_prompt(menu)));
543 str_printf(r, " (%s [=%s])", menu->sym->name ?
544 menu->sym->name : _("<choice>"),
545 sym_get_string_value(menu->sym));
552 void get_symbol_str(struct gstr *r, struct symbol *sym)
555 struct property *prop;
557 if (sym && sym->name) {
558 str_printf(r, "Symbol: %s [=%s]\n", sym->name,
559 sym_get_string_value(sym));
560 str_printf(r, "Type : %s\n", sym_type_name(sym->type));
561 if (sym->type == S_INT || sym->type == S_HEX) {
562 prop = sym_get_range_prop(sym);
564 str_printf(r, "Range : ");
565 expr_gstr_print(prop->expr, r);
570 for_all_prompts(sym, prop)
571 get_prompt_str(r, prop);
573 for_all_properties(sym, prop, P_SELECT) {
575 str_append(r, " Selects: ");
578 str_printf(r, " && ");
579 expr_gstr_print(prop->expr, r);
583 if (sym->rev_dep.expr) {
584 str_append(r, _(" Selected by: "));
585 expr_gstr_print(sym->rev_dep.expr, r);
588 str_append(r, "\n\n");
591 struct gstr get_relations_str(struct symbol **sym_arr)
594 struct gstr res = str_new();
597 for (i = 0; sym_arr && (sym = sym_arr[i]); i++)
598 get_symbol_str(&res, sym);
600 str_append(&res, _("No matches found.\n"));
605 void menu_get_ext_help(struct menu *menu, struct gstr *help)
607 struct symbol *sym = menu->sym;
609 if (menu_has_help(menu)) {
611 str_printf(help, "%s%s:\n\n", CONFIG_, sym->name);
612 str_append(help, _(menu_get_help(menu)));
613 str_append(help, "\n");
616 str_append(help, nohelp_text);
619 get_symbol_str(help, sym);