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.
10 #include <sys/utsname.h>
12 #define LKC_DIRECT_LINK
15 struct symbol symbol_yes = {
18 .flags = SYMBOL_CONST|SYMBOL_VALID,
22 .flags = SYMBOL_CONST|SYMBOL_VALID,
26 .flags = SYMBOL_CONST|SYMBOL_VALID,
30 .flags = SYMBOL_VALID,
33 struct symbol *sym_defconfig_list;
34 struct symbol *modules_sym;
37 struct expr *sym_env_list;
39 static void sym_add_default(struct symbol *sym, const char *def)
41 struct property *prop = prop_alloc(P_DEFAULT, sym);
43 prop->expr = expr_alloc_symbol(sym_lookup(def, SYMBOL_CONST));
50 static bool inited = false;
58 sym = sym_lookup("UNAME_RELEASE", 0);
60 sym->flags |= SYMBOL_AUTO;
61 sym_add_default(sym, uts.release);
64 enum symbol_type sym_get_type(struct symbol *sym)
66 enum symbol_type type = sym->type;
68 if (type == S_TRISTATE) {
69 if (sym_is_choice_value(sym) && sym->visible == yes)
71 else if (modules_val == no)
77 const char *sym_type_name(enum symbol_type type)
98 struct property *sym_get_choice_prop(struct symbol *sym)
100 struct property *prop;
102 for_all_choices(sym, prop)
107 struct property *sym_get_env_prop(struct symbol *sym)
109 struct property *prop;
111 for_all_properties(sym, prop, P_ENV)
116 struct property *sym_get_default_prop(struct symbol *sym)
118 struct property *prop;
120 for_all_defaults(sym, prop) {
121 prop->visible.tri = expr_calc_value(prop->visible.expr);
122 if (prop->visible.tri != no)
128 static struct property *sym_get_range_prop(struct symbol *sym)
130 struct property *prop;
132 for_all_properties(sym, prop, P_RANGE) {
133 prop->visible.tri = expr_calc_value(prop->visible.expr);
134 if (prop->visible.tri != no)
140 static int sym_get_range_val(struct symbol *sym, int base)
153 return strtol(sym->curr.val, NULL, base);
156 static void sym_validate_range(struct symbol *sym)
158 struct property *prop;
172 prop = sym_get_range_prop(sym);
175 val = strtol(sym->curr.val, NULL, base);
176 val2 = sym_get_range_val(prop->expr->left.sym, base);
178 val2 = sym_get_range_val(prop->expr->right.sym, base);
182 if (sym->type == S_INT)
183 sprintf(str, "%d", val2);
185 sprintf(str, "0x%x", val2);
186 sym->curr.val = strdup(str);
189 static void sym_calc_visibility(struct symbol *sym)
191 struct property *prop;
194 /* any prompt visible? */
196 for_all_prompts(sym, prop) {
197 prop->visible.tri = expr_calc_value(prop->visible.expr);
198 tri = EXPR_OR(tri, prop->visible.tri);
200 if (tri == mod && (sym->type != S_TRISTATE || modules_val == no))
202 if (sym->visible != tri) {
204 sym_set_changed(sym);
206 if (sym_is_choice_value(sym))
208 /* defaulting to "yes" if no explicit "depends on" are given */
210 if (sym->dir_dep.expr)
211 tri = expr_calc_value(sym->dir_dep.expr);
214 if (sym->dir_dep.tri != tri) {
215 sym->dir_dep.tri = tri;
216 sym_set_changed(sym);
219 if (sym->rev_dep.expr)
220 tri = expr_calc_value(sym->rev_dep.expr);
221 if (tri == mod && sym_get_type(sym) == S_BOOLEAN)
223 if (sym->rev_dep.tri != tri) {
224 sym->rev_dep.tri = tri;
225 sym_set_changed(sym);
230 * Find the default symbol for a choice.
231 * First try the default values for the choice symbol
232 * Next locate the first visible choice value
233 * Return NULL if none was found
235 struct symbol *sym_choice_default(struct symbol *sym)
237 struct symbol *def_sym;
238 struct property *prop;
241 /* any of the defaults visible? */
242 for_all_defaults(sym, prop) {
243 prop->visible.tri = expr_calc_value(prop->visible.expr);
244 if (prop->visible.tri == no)
246 def_sym = prop_get_symbol(prop);
247 if (def_sym->visible != no)
251 /* just get the first visible value */
252 prop = sym_get_choice_prop(sym);
253 expr_list_for_each_sym(prop->expr, e, def_sym)
254 if (def_sym->visible != no)
257 /* failed to locate any defaults */
261 static struct symbol *sym_calc_choice(struct symbol *sym)
263 struct symbol *def_sym;
264 struct property *prop;
267 /* first calculate all choice values' visibilities */
268 prop = sym_get_choice_prop(sym);
269 expr_list_for_each_sym(prop->expr, e, def_sym)
270 sym_calc_visibility(def_sym);
272 /* is the user choice visible? */
273 def_sym = sym->def[S_DEF_USER].val;
274 if (def_sym && def_sym->visible != no)
277 def_sym = sym_choice_default(sym);
280 /* no choice? reset tristate value */
286 void sym_calc_value(struct symbol *sym)
288 struct symbol_value newval, oldval;
289 struct property *prop;
295 if (sym->flags & SYMBOL_VALID)
297 sym->flags |= SYMBOL_VALID;
305 newval = symbol_empty.curr;
309 newval = symbol_no.curr;
312 sym->curr.val = sym->name;
316 if (!sym_is_choice_value(sym))
317 sym->flags &= ~SYMBOL_WRITE;
319 sym_calc_visibility(sym);
321 /* set default if recursively called */
324 switch (sym_get_type(sym)) {
327 if (sym_is_choice_value(sym) && sym->visible == yes) {
328 prop = sym_get_choice_prop(sym);
329 newval.tri = (prop_get_symbol(prop)->curr.val == sym) ? yes : no;
331 if (sym->visible != no) {
332 /* if the symbol is visible use the user value
333 * if available, otherwise try the default value
335 sym->flags |= SYMBOL_WRITE;
336 if (sym_has_value(sym)) {
337 newval.tri = EXPR_AND(sym->def[S_DEF_USER].tri,
342 if (sym->rev_dep.tri != no)
343 sym->flags |= SYMBOL_WRITE;
344 if (!sym_is_choice(sym)) {
345 prop = sym_get_default_prop(sym);
347 sym->flags |= SYMBOL_WRITE;
348 newval.tri = EXPR_AND(expr_calc_value(prop->expr),
353 if (sym->dir_dep.tri == no && sym->rev_dep.tri != no) {
355 e = expr_simplify_unmet_dep(sym->rev_dep.expr,
357 fprintf(stderr, "warning: (");
358 expr_fprint(e, stderr);
359 fprintf(stderr, ") selects %s which has unmet direct dependencies (",
361 expr_fprint(sym->dir_dep.expr, stderr);
362 fprintf(stderr, ")\n");
365 newval.tri = EXPR_OR(newval.tri, sym->rev_dep.tri);
367 if (newval.tri == mod && sym_get_type(sym) == S_BOOLEAN)
373 if (sym->visible != no) {
374 sym->flags |= SYMBOL_WRITE;
375 if (sym_has_value(sym)) {
376 newval.val = sym->def[S_DEF_USER].val;
380 prop = sym_get_default_prop(sym);
382 struct symbol *ds = prop_get_symbol(prop);
384 sym->flags |= SYMBOL_WRITE;
386 newval.val = ds->curr.val;
395 if (sym_is_choice(sym) && newval.tri == yes)
396 sym->curr.val = sym_calc_choice(sym);
397 sym_validate_range(sym);
399 if (memcmp(&oldval, &sym->curr, sizeof(oldval))) {
400 sym_set_changed(sym);
401 if (modules_sym == sym) {
402 sym_set_all_changed();
403 modules_val = modules_sym->curr.tri;
407 if (sym_is_choice(sym)) {
408 struct symbol *choice_sym;
410 prop = sym_get_choice_prop(sym);
411 expr_list_for_each_sym(prop->expr, e, choice_sym) {
412 if ((sym->flags & SYMBOL_WRITE) &&
413 choice_sym->visible != no)
414 choice_sym->flags |= SYMBOL_WRITE;
415 if (sym->flags & SYMBOL_CHANGED)
416 sym_set_changed(choice_sym);
420 if (sym->flags & SYMBOL_AUTO)
421 sym->flags &= ~SYMBOL_WRITE;
424 void sym_clear_all_valid(void)
429 for_all_symbols(i, sym)
430 sym->flags &= ~SYMBOL_VALID;
431 sym_add_change_count(1);
433 sym_calc_value(modules_sym);
436 void sym_set_changed(struct symbol *sym)
438 struct property *prop;
440 sym->flags |= SYMBOL_CHANGED;
441 for (prop = sym->prop; prop; prop = prop->next) {
443 prop->menu->flags |= MENU_CHANGED;
447 void sym_set_all_changed(void)
452 for_all_symbols(i, sym)
453 sym_set_changed(sym);
456 bool sym_tristate_within_range(struct symbol *sym, tristate val)
458 int type = sym_get_type(sym);
460 if (sym->visible == no)
463 if (type != S_BOOLEAN && type != S_TRISTATE)
466 if (type == S_BOOLEAN && val == mod)
468 if (sym->visible <= sym->rev_dep.tri)
470 if (sym_is_choice_value(sym) && sym->visible == yes)
472 return val >= sym->rev_dep.tri && val <= sym->visible;
475 bool sym_set_tristate_value(struct symbol *sym, tristate val)
477 tristate oldval = sym_get_tristate_value(sym);
479 if (oldval != val && !sym_tristate_within_range(sym, val))
482 if (!(sym->flags & SYMBOL_DEF_USER)) {
483 sym->flags |= SYMBOL_DEF_USER;
484 sym_set_changed(sym);
487 * setting a choice value also resets the new flag of the choice
488 * symbol and all other choice values.
490 if (sym_is_choice_value(sym) && val == yes) {
491 struct symbol *cs = prop_get_symbol(sym_get_choice_prop(sym));
492 struct property *prop;
495 cs->def[S_DEF_USER].val = sym;
496 cs->flags |= SYMBOL_DEF_USER;
497 prop = sym_get_choice_prop(cs);
498 for (e = prop->expr; e; e = e->left.expr) {
499 if (e->right.sym->visible != no)
500 e->right.sym->flags |= SYMBOL_DEF_USER;
504 sym->def[S_DEF_USER].tri = val;
506 sym_clear_all_valid();
511 tristate sym_toggle_tristate_value(struct symbol *sym)
513 tristate oldval, newval;
515 oldval = newval = sym_get_tristate_value(sym);
528 if (sym_set_tristate_value(sym, newval))
530 } while (oldval != newval);
534 bool sym_string_valid(struct symbol *sym, const char *str)
547 if (ch == '0' && *str != 0)
549 while ((ch = *str++)) {
555 if (str[0] == '0' && (str[1] == 'x' || str[1] == 'X'))
561 } while ((ch = *str++));
577 bool sym_string_within_range(struct symbol *sym, const char *str)
579 struct property *prop;
584 return sym_string_valid(sym, str);
586 if (!sym_string_valid(sym, str))
588 prop = sym_get_range_prop(sym);
591 val = strtol(str, NULL, 10);
592 return val >= sym_get_range_val(prop->expr->left.sym, 10) &&
593 val <= sym_get_range_val(prop->expr->right.sym, 10);
595 if (!sym_string_valid(sym, str))
597 prop = sym_get_range_prop(sym);
600 val = strtol(str, NULL, 16);
601 return val >= sym_get_range_val(prop->expr->left.sym, 16) &&
602 val <= sym_get_range_val(prop->expr->right.sym, 16);
607 return sym_tristate_within_range(sym, yes);
609 return sym_tristate_within_range(sym, mod);
611 return sym_tristate_within_range(sym, no);
619 bool sym_set_string_value(struct symbol *sym, const char *newval)
630 return sym_set_tristate_value(sym, yes);
632 return sym_set_tristate_value(sym, mod);
634 return sym_set_tristate_value(sym, no);
641 if (!sym_string_within_range(sym, newval))
644 if (!(sym->flags & SYMBOL_DEF_USER)) {
645 sym->flags |= SYMBOL_DEF_USER;
646 sym_set_changed(sym);
649 oldval = sym->def[S_DEF_USER].val;
650 size = strlen(newval) + 1;
651 if (sym->type == S_HEX && (newval[0] != '0' || (newval[1] != 'x' && newval[1] != 'X'))) {
653 sym->def[S_DEF_USER].val = val = malloc(size);
656 } else if (!oldval || strcmp(oldval, newval))
657 sym->def[S_DEF_USER].val = val = malloc(size);
662 free((void *)oldval);
663 sym_clear_all_valid();
669 * Find the default value associated to a symbol.
670 * For tristate symbol handle the modules=n case
671 * in which case "m" becomes "y".
672 * If the symbol does not have any default then fallback
673 * to the fixed default values.
675 const char *sym_get_string_default(struct symbol *sym)
677 struct property *prop;
682 sym_calc_visibility(sym);
683 sym_calc_value(modules_sym);
684 val = symbol_no.curr.tri;
685 str = symbol_empty.curr.val;
687 /* If symbol has a default value look it up */
688 prop = sym_get_default_prop(sym);
693 /* The visibility may limit the value from yes => mod */
694 val = EXPR_AND(expr_calc_value(prop->expr), prop->visible.tri);
698 * The following fails to handle the situation
699 * where a default value is further limited by
702 ds = prop_get_symbol(prop);
705 str = (const char *)ds->curr.val;
710 /* Handle select statements */
711 val = EXPR_OR(val, sym->rev_dep.tri);
713 /* transpose mod to yes if modules are not enabled */
715 if (!sym_is_choice_value(sym) && modules_sym->curr.tri == no)
718 /* transpose mod to yes if type is bool */
719 if (sym->type == S_BOOLEAN && val == mod)
727 case mod: return "m";
728 case yes: return "y";
742 const char *sym_get_string_value(struct symbol *sym)
749 val = sym_get_tristate_value(sym);
762 return (const char *)sym->curr.val;
765 bool sym_is_changable(struct symbol *sym)
767 return sym->visible > sym->rev_dep.tri;
770 static unsigned strhash(const char *s)
773 unsigned hash = 2166136261U;
775 hash = (hash ^ *s) * 0x01000193;
779 struct symbol *sym_lookup(const char *name, int flags)
781 struct symbol *symbol;
786 if (name[0] && !name[1]) {
788 case 'y': return &symbol_yes;
789 case 'm': return &symbol_mod;
790 case 'n': return &symbol_no;
793 hash = strhash(name) % SYMBOL_HASHSIZE;
795 for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
797 !strcmp(symbol->name, name) &&
798 (flags ? symbol->flags & flags
799 : !(symbol->flags & (SYMBOL_CONST|SYMBOL_CHOICE))))
802 new_name = strdup(name);
808 symbol = malloc(sizeof(*symbol));
809 memset(symbol, 0, sizeof(*symbol));
810 symbol->name = new_name;
811 symbol->type = S_UNKNOWN;
812 symbol->flags |= flags;
814 symbol->next = symbol_hash[hash];
815 symbol_hash[hash] = symbol;
820 struct symbol *sym_find(const char *name)
822 struct symbol *symbol = NULL;
828 if (name[0] && !name[1]) {
830 case 'y': return &symbol_yes;
831 case 'm': return &symbol_mod;
832 case 'n': return &symbol_no;
835 hash = strhash(name) % SYMBOL_HASHSIZE;
837 for (symbol = symbol_hash[hash]; symbol; symbol = symbol->next) {
839 !strcmp(symbol->name, name) &&
840 !(symbol->flags & SYMBOL_CONST))
848 * Expand symbol's names embedded in the string given in argument. Symbols'
849 * name to be expanded shall be prefixed by a '$'. Unknown symbol expands to
852 const char *sym_expand_string_value(const char *in)
858 reslen = strlen(in) + 1;
859 res = malloc(reslen);
862 while ((src = strchr(in, '$'))) {
863 char *p, name[SYMBOL_MAXLENGTH];
864 const char *symval = "";
868 strncat(res, in, src - in);
872 while (isalnum(*src) || *src == '_')
876 sym = sym_find(name);
879 symval = sym_get_string_value(sym);
882 newlen = strlen(res) + strlen(symval) + strlen(src) + 1;
883 if (newlen > reslen) {
885 res = realloc(res, reslen);
896 struct symbol **sym_re_search(const char *pattern)
898 struct symbol *sym, **sym_arr = NULL;
904 if (strlen(pattern) == 0)
906 if (regcomp(&re, pattern, REG_EXTENDED|REG_NOSUB|REG_ICASE))
909 for_all_symbols(i, sym) {
910 if (sym->flags & SYMBOL_CONST || !sym->name)
912 if (regexec(&re, sym->name, 0, NULL, 0))
914 if (cnt + 1 >= size) {
917 sym_arr = realloc(sym_arr, size * sizeof(struct symbol *));
924 sym_arr[cnt++] = sym;
934 * When we check for recursive dependencies we use a stack to save
935 * current state so we can print out relevant info to user.
936 * The entries are located on the call stack so no need to free memory.
937 * Note inser() remove() must always match to properly clear the stack.
939 static struct dep_stack {
940 struct dep_stack *prev, *next;
942 struct property *prop;
946 static void dep_stack_insert(struct dep_stack *stack, struct symbol *sym)
948 memset(stack, 0, sizeof(*stack));
950 check_top->next = stack;
951 stack->prev = check_top;
956 static void dep_stack_remove(void)
958 check_top = check_top->prev;
960 check_top->next = NULL;
964 * Called when we have detected a recursive dependency.
965 * check_top point to the top of the stact so we use
966 * the ->prev pointer to locate the bottom of the stack.
968 static void sym_check_print_recursive(struct symbol *last_sym)
970 struct dep_stack *stack;
971 struct symbol *sym, *next_sym;
972 struct menu *menu = NULL;
973 struct property *prop;
974 struct dep_stack cv_stack;
976 if (sym_is_choice_value(last_sym)) {
977 dep_stack_insert(&cv_stack, last_sym);
978 last_sym = prop_get_symbol(sym_get_choice_prop(last_sym));
981 for (stack = check_top; stack != NULL; stack = stack->prev)
982 if (stack->sym == last_sym)
985 fprintf(stderr, "unexpected recursive dependency error\n");
989 for (; stack; stack = stack->next) {
991 next_sym = stack->next ? stack->next->sym : last_sym;
994 prop = stack->sym->prop;
996 /* for choice values find the menu entry (used below) */
997 if (sym_is_choice(sym) || sym_is_choice_value(sym)) {
998 for (prop = sym->prop; prop; prop = prop->next) {
1004 if (stack->sym == last_sym)
1005 fprintf(stderr, "%s:%d:error: recursive dependency detected!\n",
1006 prop->file->name, prop->lineno);
1008 fprintf(stderr, "%s:%d:\tsymbol %s %s value contains %s\n",
1009 prop->file->name, prop->lineno,
1010 sym->name ? sym->name : "<choice>",
1011 prop_get_type_name(prop->type),
1012 next_sym->name ? next_sym->name : "<choice>");
1013 } else if (stack->prop) {
1014 fprintf(stderr, "%s:%d:\tsymbol %s depends on %s\n",
1015 prop->file->name, prop->lineno,
1016 sym->name ? sym->name : "<choice>",
1017 next_sym->name ? next_sym->name : "<choice>");
1018 } else if (sym_is_choice(sym)) {
1019 fprintf(stderr, "%s:%d:\tchoice %s contains symbol %s\n",
1020 menu->file->name, menu->lineno,
1021 sym->name ? sym->name : "<choice>",
1022 next_sym->name ? next_sym->name : "<choice>");
1023 } else if (sym_is_choice_value(sym)) {
1024 fprintf(stderr, "%s:%d:\tsymbol %s is part of choice %s\n",
1025 menu->file->name, menu->lineno,
1026 sym->name ? sym->name : "<choice>",
1027 next_sym->name ? next_sym->name : "<choice>");
1029 fprintf(stderr, "%s:%d:\tsymbol %s is selected by %s\n",
1030 prop->file->name, prop->lineno,
1031 sym->name ? sym->name : "<choice>",
1032 next_sym->name ? next_sym->name : "<choice>");
1036 if (check_top == &cv_stack)
1040 static struct symbol *sym_check_expr_deps(struct expr *e)
1049 sym = sym_check_expr_deps(e->left.expr);
1052 return sym_check_expr_deps(e->right.expr);
1054 return sym_check_expr_deps(e->left.expr);
1057 sym = sym_check_deps(e->left.sym);
1060 return sym_check_deps(e->right.sym);
1062 return sym_check_deps(e->left.sym);
1066 printf("Oops! How to check %d?\n", e->type);
1070 /* return NULL when dependencies are OK */
1071 static struct symbol *sym_check_sym_deps(struct symbol *sym)
1073 struct symbol *sym2;
1074 struct property *prop;
1075 struct dep_stack stack;
1077 dep_stack_insert(&stack, sym);
1079 sym2 = sym_check_expr_deps(sym->rev_dep.expr);
1083 for (prop = sym->prop; prop; prop = prop->next) {
1084 if (prop->type == P_CHOICE || prop->type == P_SELECT)
1087 sym2 = sym_check_expr_deps(prop->visible.expr);
1090 if (prop->type != P_DEFAULT || sym_is_choice(sym))
1092 stack.expr = prop->expr;
1093 sym2 = sym_check_expr_deps(prop->expr);
1105 static struct symbol *sym_check_choice_deps(struct symbol *choice)
1107 struct symbol *sym, *sym2;
1108 struct property *prop;
1110 struct dep_stack stack;
1112 dep_stack_insert(&stack, choice);
1114 prop = sym_get_choice_prop(choice);
1115 expr_list_for_each_sym(prop->expr, e, sym)
1116 sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
1118 choice->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
1119 sym2 = sym_check_sym_deps(choice);
1120 choice->flags &= ~SYMBOL_CHECK;
1124 expr_list_for_each_sym(prop->expr, e, sym) {
1125 sym2 = sym_check_sym_deps(sym);
1130 expr_list_for_each_sym(prop->expr, e, sym)
1131 sym->flags &= ~SYMBOL_CHECK;
1133 if (sym2 && sym_is_choice_value(sym2) &&
1134 prop_get_symbol(sym_get_choice_prop(sym2)) == choice)
1142 struct symbol *sym_check_deps(struct symbol *sym)
1144 struct symbol *sym2;
1145 struct property *prop;
1147 if (sym->flags & SYMBOL_CHECK) {
1148 sym_check_print_recursive(sym);
1151 if (sym->flags & SYMBOL_CHECKED)
1154 if (sym_is_choice_value(sym)) {
1155 struct dep_stack stack;
1157 /* for choice groups start the check with main choice symbol */
1158 dep_stack_insert(&stack, sym);
1159 prop = sym_get_choice_prop(sym);
1160 sym2 = sym_check_deps(prop_get_symbol(prop));
1162 } else if (sym_is_choice(sym)) {
1163 sym2 = sym_check_choice_deps(sym);
1165 sym->flags |= (SYMBOL_CHECK | SYMBOL_CHECKED);
1166 sym2 = sym_check_sym_deps(sym);
1167 sym->flags &= ~SYMBOL_CHECK;
1170 if (sym2 && sym2 == sym)
1176 struct property *prop_alloc(enum prop_type type, struct symbol *sym)
1178 struct property *prop;
1179 struct property **propp;
1181 prop = malloc(sizeof(*prop));
1182 memset(prop, 0, sizeof(*prop));
1185 prop->file = current_file;
1186 prop->lineno = zconf_lineno();
1188 /* append property to the prop list of symbol */
1190 for (propp = &sym->prop; *propp; propp = &(*propp)->next)
1198 struct symbol *prop_get_symbol(struct property *prop)
1200 if (prop->expr && (prop->expr->type == E_SYMBOL ||
1201 prop->expr->type == E_LIST))
1202 return prop->expr->left.sym;
1206 const char *prop_get_type_name(enum prop_type type)
1233 static void prop_add_env(const char *env)
1235 struct symbol *sym, *sym2;
1236 struct property *prop;
1239 sym = current_entry->sym;
1240 sym->flags |= SYMBOL_AUTO;
1241 for_all_properties(sym, prop, P_ENV) {
1242 sym2 = prop_get_symbol(prop);
1243 if (strcmp(sym2->name, env))
1244 menu_warn(current_entry, "redefining environment symbol from %s",
1249 prop = prop_alloc(P_ENV, sym);
1250 prop->expr = expr_alloc_symbol(sym_lookup(env, SYMBOL_CONST));
1252 sym_env_list = expr_alloc_one(E_LIST, sym_env_list);
1253 sym_env_list->right.sym = sym;
1257 sym_add_default(sym, p);