tools/patchelf: update to 0.18.0

[openwrt/staging/dedeckeh.git] / scripts / config / symbol.c

diff --git a/scripts/config/symbol.c b/scripts/config/symbol.c
index 5c6f54031437a0d64b98ac6942d6892550c0b753..d97b56ab0ece7a0af72eb8019f3127bb1c3c19b7 100644 (file)
--- a/scripts/config/symbol.c
+++ b/scripts/config/symbol.c
@@ -1,13 +1,13 @@
-// SPDX-License-Identifier: GPL-2.0
+// SPDX-License-Identifier: GPL-2.0-only
 /*
  * Copyright (C) 2002 Roman Zippel <zippel@linux-m68k.org>
  */
 
+#include <sys/types.h>
 #include <ctype.h>
 #include <stdlib.h>
 #include <string.h>
 #include <regex.h>
-#include <sys/utsname.h>
 
 #include "lkc.h"
 
@@ -15,23 +15,29 @@ struct symbol symbol_yes = {
        .name = "y",
        .curr = { "y", yes },
        .flags = SYMBOL_CONST|SYMBOL_VALID,
-}, symbol_mod = {
+};
+
+struct symbol symbol_mod = {
        .name = "m",
        .curr = { "m", mod },
        .flags = SYMBOL_CONST|SYMBOL_VALID,
-}, symbol_no = {
+};
+
+struct symbol symbol_no = {
        .name = "n",
        .curr = { "n", no },
        .flags = SYMBOL_CONST|SYMBOL_VALID,
-}, symbol_empty = {
+};
+
+static struct symbol symbol_empty = {
        .name = "",
        .curr = { "", no },
        .flags = SYMBOL_VALID,
 };
 
-struct symbol *sym_defconfig_list;
 struct symbol *modules_sym;
-tristate modules_val;
+static tristate modules_val;
+int recursive_is_error;
 
 enum symbol_type sym_get_type(struct symbol *sym)
 {
@@ -221,7 +227,7 @@ static void sym_calc_visibility(struct symbol *sym)
                sym_set_changed(sym);
        }
        tri = no;
-       if (sym->implied.expr && sym->dir_dep.tri != no)
+       if (sym->implied.expr)
                tri = expr_calc_value(sym->implied.expr);
        if (tri == mod && sym_get_type(sym) == S_BOOLEAN)
                tri = yes;
@@ -372,17 +378,17 @@ void sym_calc_value(struct symbol *sym)
                                if (sym->implied.tri != no) {
                                        sym->flags |= SYMBOL_WRITE;
                                        newval.tri = EXPR_OR(newval.tri, sym->implied.tri);
+                                       newval.tri = EXPR_AND(newval.tri,
+                                                             sym->dir_dep.tri);
                                }
                        }
                calc_newval:
-                       if (sym->dir_dep.tri < sym->rev_dep.tri) {
+                       if (sym->dir_dep.tri == no && sym->rev_dep.tri != no)
                                newval.tri = no;
-                       } else {
+                       else
                                newval.tri = EXPR_OR(newval.tri, sym->rev_dep.tri);
-                       }
                }
-               if (newval.tri == mod &&
-                   (sym_get_type(sym) == S_BOOLEAN || sym->implied.tri == yes))
+               if (newval.tri == mod && sym_get_type(sym) == S_BOOLEAN)
                        newval.tri = yes;
                break;
        case S_STRING:
@@ -446,7 +452,7 @@ void sym_clear_all_valid(void)
 
        for_all_symbols(i, sym)
                sym->flags &= ~SYMBOL_VALID;
-       sym_add_change_count(1);
+       conf_set_changed(true);
        sym_calc_value(modules_sym);
 }
 
@@ -464,8 +470,6 @@ bool sym_tristate_within_range(struct symbol *sym, tristate val)
                return false;
        if (sym->visible <= sym->rev_dep.tri)
                return false;
-       if (sym->implied.tri == yes && val == mod)
-               return false;
        if (sym_is_choice_value(sym) && sym->visible == yes)
                return val == yes;
        return val >= sym->rev_dep.tri && val <= sym->visible;
@@ -812,7 +816,7 @@ struct symbol *sym_lookup(const char *name, int flags)
        memset(symbol, 0, sizeof(*symbol));
        symbol->name = new_name;
        symbol->type = S_UNKNOWN;
-       symbol->flags |= flags;
+       symbol->flags = flags;
 
        symbol->next = symbol_hash[hash];
        symbol_hash[hash] = symbol;
@@ -1250,10 +1254,8 @@ struct symbol *sym_check_deps(struct symbol *sym)
                sym->flags &= ~SYMBOL_CHECK;
        }
 
-#ifdef WARN_RECURSIVE_DEP
-       if (sym2 && sym2 == sym)
+       if (!recursive_is_error && sym2 && sym2 == sym)
                sym2 = NULL;
-#endif
 
        return sym2;
 }