mirror of
https://github.com/u-boot/u-boot.git
synced 2025-05-08 19:11:53 +00:00
kconfig: re-sync with Linux 4.10
Re-sync all files under the scripts/kconfig directory with Linux 4.10. Some parts include U-Boot own modification. I made sure to not revert the following commits:5b8031ccb4("Add more SPDX-License-Identifier tags")192bc6948b("Fix GCC format-security errors and convert sprintfs.")da58dec866("Various Makefiles: Add SPDX-License-Identifier tags")20c20826ef("Kconfig: Enable usage of escape char '\' in string values") Signed-off-by: Masahiro Yamada <yamada.masahiro@socionext.com>
This commit is contained in:
Masahiro Yamada
Tom Rini
parent
554c73c025
commit
bf7ab1e70f
19 changed files with 2025 additions and 1734 deletions
|
|
@ -13,9 +13,6 @@
|
|||
|
||||
static int expr_eq(struct expr *e1, struct expr *e2);
|
||||
static struct expr *expr_eliminate_yn(struct expr *e);
|
||||
static struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2);
|
||||
static struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2);
|
||||
static void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2);
|
||||
|
||||
struct expr *expr_alloc_symbol(struct symbol *sym)
|
||||
{
|
||||
|
|
@ -82,6 +79,10 @@ struct expr *expr_copy(const struct expr *org)
|
|||
e->left.expr = expr_copy(org->left.expr);
|
||||
break;
|
||||
case E_EQUAL:
|
||||
case E_GEQ:
|
||||
case E_GTH:
|
||||
case E_LEQ:
|
||||
case E_LTH:
|
||||
case E_UNEQUAL:
|
||||
e->left.sym = org->left.sym;
|
||||
e->right.sym = org->right.sym;
|
||||
|
|
@ -114,6 +115,10 @@ void expr_free(struct expr *e)
|
|||
expr_free(e->left.expr);
|
||||
return;
|
||||
case E_EQUAL:
|
||||
case E_GEQ:
|
||||
case E_GTH:
|
||||
case E_LEQ:
|
||||
case E_LTH:
|
||||
case E_UNEQUAL:
|
||||
break;
|
||||
case E_OR:
|
||||
|
|
@ -200,6 +205,10 @@ static int expr_eq(struct expr *e1, struct expr *e2)
|
|||
return 0;
|
||||
switch (e1->type) {
|
||||
case E_EQUAL:
|
||||
case E_GEQ:
|
||||
case E_GTH:
|
||||
case E_LEQ:
|
||||
case E_LTH:
|
||||
case E_UNEQUAL:
|
||||
return e1->left.sym == e2->left.sym && e1->right.sym == e2->right.sym;
|
||||
case E_SYMBOL:
|
||||
|
|
@ -559,62 +568,6 @@ static void expr_eliminate_dups1(enum expr_type type, struct expr **ep1, struct
|
|||
#undef e2
|
||||
}
|
||||
|
||||
static void expr_eliminate_dups2(enum expr_type type, struct expr **ep1, struct expr **ep2)
|
||||
{
|
||||
#define e1 (*ep1)
|
||||
#define e2 (*ep2)
|
||||
struct expr *tmp, *tmp1, *tmp2;
|
||||
|
||||
if (e1->type == type) {
|
||||
expr_eliminate_dups2(type, &e1->left.expr, &e2);
|
||||
expr_eliminate_dups2(type, &e1->right.expr, &e2);
|
||||
return;
|
||||
}
|
||||
if (e2->type == type) {
|
||||
expr_eliminate_dups2(type, &e1, &e2->left.expr);
|
||||
expr_eliminate_dups2(type, &e1, &e2->right.expr);
|
||||
}
|
||||
if (e1 == e2)
|
||||
return;
|
||||
|
||||
switch (e1->type) {
|
||||
case E_OR:
|
||||
expr_eliminate_dups2(e1->type, &e1, &e1);
|
||||
// (FOO || BAR) && (!FOO && !BAR) -> n
|
||||
tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
|
||||
tmp2 = expr_copy(e2);
|
||||
tmp = expr_extract_eq_and(&tmp1, &tmp2);
|
||||
if (expr_is_yes(tmp1)) {
|
||||
expr_free(e1);
|
||||
e1 = expr_alloc_symbol(&symbol_no);
|
||||
trans_count++;
|
||||
}
|
||||
expr_free(tmp2);
|
||||
expr_free(tmp1);
|
||||
expr_free(tmp);
|
||||
break;
|
||||
case E_AND:
|
||||
expr_eliminate_dups2(e1->type, &e1, &e1);
|
||||
// (FOO && BAR) || (!FOO || !BAR) -> y
|
||||
tmp1 = expr_transform(expr_alloc_one(E_NOT, expr_copy(e1)));
|
||||
tmp2 = expr_copy(e2);
|
||||
tmp = expr_extract_eq_or(&tmp1, &tmp2);
|
||||
if (expr_is_no(tmp1)) {
|
||||
expr_free(e1);
|
||||
e1 = expr_alloc_symbol(&symbol_yes);
|
||||
trans_count++;
|
||||
}
|
||||
expr_free(tmp2);
|
||||
expr_free(tmp1);
|
||||
expr_free(tmp);
|
||||
break;
|
||||
default:
|
||||
;
|
||||
}
|
||||
#undef e1
|
||||
#undef e2
|
||||
}
|
||||
|
||||
struct expr *expr_eliminate_dups(struct expr *e)
|
||||
{
|
||||
int oldcount;
|
||||
|
|
@ -627,7 +580,6 @@ struct expr *expr_eliminate_dups(struct expr *e)
|
|||
switch (e->type) {
|
||||
case E_OR: case E_AND:
|
||||
expr_eliminate_dups1(e->type, &e, &e);
|
||||
expr_eliminate_dups2(e->type, &e, &e);
|
||||
default:
|
||||
;
|
||||
}
|
||||
|
|
@ -647,6 +599,10 @@ struct expr *expr_transform(struct expr *e)
|
|||
return NULL;
|
||||
switch (e->type) {
|
||||
case E_EQUAL:
|
||||
case E_GEQ:
|
||||
case E_GTH:
|
||||
case E_LEQ:
|
||||
case E_LTH:
|
||||
case E_UNEQUAL:
|
||||
case E_SYMBOL:
|
||||
case E_LIST:
|
||||
|
|
@ -719,6 +675,22 @@ struct expr *expr_transform(struct expr *e)
|
|||
e = tmp;
|
||||
e->type = e->type == E_EQUAL ? E_UNEQUAL : E_EQUAL;
|
||||
break;
|
||||
case E_LEQ:
|
||||
case E_GEQ:
|
||||
// !a<='x' -> a>'x'
|
||||
tmp = e->left.expr;
|
||||
free(e);
|
||||
e = tmp;
|
||||
e->type = e->type == E_LEQ ? E_GTH : E_LTH;
|
||||
break;
|
||||
case E_LTH:
|
||||
case E_GTH:
|
||||
// !a<'x' -> a>='x'
|
||||
tmp = e->left.expr;
|
||||
free(e);
|
||||
e = tmp;
|
||||
e->type = e->type == E_LTH ? E_GEQ : E_LEQ;
|
||||
break;
|
||||
case E_OR:
|
||||
// !(a || b) -> !a && !b
|
||||
tmp = e->left.expr;
|
||||
|
|
@ -789,6 +761,10 @@ int expr_contains_symbol(struct expr *dep, struct symbol *sym)
|
|||
case E_SYMBOL:
|
||||
return dep->left.sym == sym;
|
||||
case E_EQUAL:
|
||||
case E_GEQ:
|
||||
case E_GTH:
|
||||
case E_LEQ:
|
||||
case E_LTH:
|
||||
case E_UNEQUAL:
|
||||
return dep->left.sym == sym ||
|
||||
dep->right.sym == sym;
|
||||
|
|
@ -829,57 +805,6 @@ bool expr_depends_symbol(struct expr *dep, struct symbol *sym)
|
|||
return false;
|
||||
}
|
||||
|
||||
static struct expr *expr_extract_eq_and(struct expr **ep1, struct expr **ep2)
|
||||
{
|
||||
struct expr *tmp = NULL;
|
||||
expr_extract_eq(E_AND, &tmp, ep1, ep2);
|
||||
if (tmp) {
|
||||
*ep1 = expr_eliminate_yn(*ep1);
|
||||
*ep2 = expr_eliminate_yn(*ep2);
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static struct expr *expr_extract_eq_or(struct expr **ep1, struct expr **ep2)
|
||||
{
|
||||
struct expr *tmp = NULL;
|
||||
expr_extract_eq(E_OR, &tmp, ep1, ep2);
|
||||
if (tmp) {
|
||||
*ep1 = expr_eliminate_yn(*ep1);
|
||||
*ep2 = expr_eliminate_yn(*ep2);
|
||||
}
|
||||
return tmp;
|
||||
}
|
||||
|
||||
static void expr_extract_eq(enum expr_type type, struct expr **ep, struct expr **ep1, struct expr **ep2)
|
||||
{
|
||||
#define e1 (*ep1)
|
||||
#define e2 (*ep2)
|
||||
if (e1->type == type) {
|
||||
expr_extract_eq(type, ep, &e1->left.expr, &e2);
|
||||
expr_extract_eq(type, ep, &e1->right.expr, &e2);
|
||||
return;
|
||||
}
|
||||
if (e2->type == type) {
|
||||
expr_extract_eq(type, ep, ep1, &e2->left.expr);
|
||||
expr_extract_eq(type, ep, ep1, &e2->right.expr);
|
||||
return;
|
||||
}
|
||||
if (expr_eq(e1, e2)) {
|
||||
*ep = *ep ? expr_alloc_two(type, *ep, e1) : e1;
|
||||
expr_free(e2);
|
||||
if (type == E_AND) {
|
||||
e1 = expr_alloc_symbol(&symbol_yes);
|
||||
e2 = expr_alloc_symbol(&symbol_yes);
|
||||
} else if (type == E_OR) {
|
||||
e1 = expr_alloc_symbol(&symbol_no);
|
||||
e2 = expr_alloc_symbol(&symbol_no);
|
||||
}
|
||||
}
|
||||
#undef e1
|
||||
#undef e2
|
||||
}
|
||||
|
||||
struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symbol *sym)
|
||||
{
|
||||
struct expr *e1, *e2;
|
||||
|
|
@ -914,6 +839,10 @@ struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symb
|
|||
case E_NOT:
|
||||
return expr_trans_compare(e->left.expr, type == E_EQUAL ? E_UNEQUAL : E_EQUAL, sym);
|
||||
case E_UNEQUAL:
|
||||
case E_LTH:
|
||||
case E_LEQ:
|
||||
case E_GTH:
|
||||
case E_GEQ:
|
||||
case E_EQUAL:
|
||||
if (type == E_EQUAL) {
|
||||
if (sym == &symbol_yes)
|
||||
|
|
@ -941,10 +870,57 @@ struct expr *expr_trans_compare(struct expr *e, enum expr_type type, struct symb
|
|||
return NULL;
|
||||
}
|
||||
|
||||
enum string_value_kind {
|
||||
k_string,
|
||||
k_signed,
|
||||
k_unsigned,
|
||||
k_invalid
|
||||
};
|
||||
|
||||
union string_value {
|
||||
unsigned long long u;
|
||||
signed long long s;
|
||||
};
|
||||
|
||||
static enum string_value_kind expr_parse_string(const char *str,
|
||||
enum symbol_type type,
|
||||
union string_value *val)
|
||||
{
|
||||
char *tail;
|
||||
enum string_value_kind kind;
|
||||
|
||||
errno = 0;
|
||||
switch (type) {
|
||||
case S_BOOLEAN:
|
||||
case S_TRISTATE:
|
||||
return k_string;
|
||||
case S_INT:
|
||||
val->s = strtoll(str, &tail, 10);
|
||||
kind = k_signed;
|
||||
break;
|
||||
case S_HEX:
|
||||
val->u = strtoull(str, &tail, 16);
|
||||
kind = k_unsigned;
|
||||
break;
|
||||
case S_STRING:
|
||||
case S_UNKNOWN:
|
||||
val->s = strtoll(str, &tail, 0);
|
||||
kind = k_signed;
|
||||
break;
|
||||
default:
|
||||
return k_invalid;
|
||||
}
|
||||
return !errno && !*tail && tail > str && isxdigit(tail[-1])
|
||||
? kind : k_string;
|
||||
}
|
||||
|
||||
tristate expr_calc_value(struct expr *e)
|
||||
{
|
||||
tristate val1, val2;
|
||||
const char *str1, *str2;
|
||||
enum string_value_kind k1 = k_string, k2 = k_string;
|
||||
union string_value lval = {}, rval = {};
|
||||
int res;
|
||||
|
||||
if (!e)
|
||||
return yes;
|
||||
|
|
@ -965,21 +941,57 @@ tristate expr_calc_value(struct expr *e)
|
|||
val1 = expr_calc_value(e->left.expr);
|
||||
return EXPR_NOT(val1);
|
||||
case E_EQUAL:
|
||||
sym_calc_value(e->left.sym);
|
||||
sym_calc_value(e->right.sym);
|
||||
str1 = sym_get_string_value(e->left.sym);
|
||||
str2 = sym_get_string_value(e->right.sym);
|
||||
return !strcmp(str1, str2) ? yes : no;
|
||||
case E_GEQ:
|
||||
case E_GTH:
|
||||
case E_LEQ:
|
||||
case E_LTH:
|
||||
case E_UNEQUAL:
|
||||
sym_calc_value(e->left.sym);
|
||||
sym_calc_value(e->right.sym);
|
||||
str1 = sym_get_string_value(e->left.sym);
|
||||
str2 = sym_get_string_value(e->right.sym);
|
||||
return !strcmp(str1, str2) ? no : yes;
|
||||
break;
|
||||
default:
|
||||
printf("expr_calc_value: %d?\n", e->type);
|
||||
return no;
|
||||
}
|
||||
|
||||
sym_calc_value(e->left.sym);
|
||||
sym_calc_value(e->right.sym);
|
||||
str1 = sym_get_string_value(e->left.sym);
|
||||
str2 = sym_get_string_value(e->right.sym);
|
||||
|
||||
if (e->left.sym->type != S_STRING || e->right.sym->type != S_STRING) {
|
||||
k1 = expr_parse_string(str1, e->left.sym->type, &lval);
|
||||
k2 = expr_parse_string(str2, e->right.sym->type, &rval);
|
||||
}
|
||||
|
||||
if (k1 == k_string || k2 == k_string)
|
||||
res = strcmp(str1, str2);
|
||||
else if (k1 == k_invalid || k2 == k_invalid) {
|
||||
if (e->type != E_EQUAL && e->type != E_UNEQUAL) {
|
||||
printf("Cannot compare \"%s\" and \"%s\"\n", str1, str2);
|
||||
return no;
|
||||
}
|
||||
res = strcmp(str1, str2);
|
||||
} else if (k1 == k_unsigned || k2 == k_unsigned)
|
||||
res = (lval.u > rval.u) - (lval.u < rval.u);
|
||||
else /* if (k1 == k_signed && k2 == k_signed) */
|
||||
res = (lval.s > rval.s) - (lval.s < rval.s);
|
||||
|
||||
switch(e->type) {
|
||||
case E_EQUAL:
|
||||
return res ? no : yes;
|
||||
case E_GEQ:
|
||||
return res >= 0 ? yes : no;
|
||||
case E_GTH:
|
||||
return res > 0 ? yes : no;
|
||||
case E_LEQ:
|
||||
return res <= 0 ? yes : no;
|
||||
case E_LTH:
|
||||
return res < 0 ? yes : no;
|
||||
case E_UNEQUAL:
|
||||
return res ? yes : no;
|
||||
default:
|
||||
printf("expr_calc_value: relation %d?\n", e->type);
|
||||
return no;
|
||||
}
|
||||
}
|
||||
|
||||
static int expr_compare_type(enum expr_type t1, enum expr_type t2)
|
||||
|
|
@ -987,6 +999,12 @@ static int expr_compare_type(enum expr_type t1, enum expr_type t2)
|
|||
if (t1 == t2)
|
||||
return 0;
|
||||
switch (t1) {
|
||||
case E_LEQ:
|
||||
case E_LTH:
|
||||
case E_GEQ:
|
||||
case E_GTH:
|
||||
if (t2 == E_EQUAL || t2 == E_UNEQUAL)
|
||||
return 1;
|
||||
case E_EQUAL:
|
||||
case E_UNEQUAL:
|
||||
if (t2 == E_NOT)
|
||||
|
|
@ -1080,6 +1098,24 @@ void expr_print(struct expr *e, void (*fn)(void *, struct symbol *, const char *
|
|||
fn(data, NULL, "=");
|
||||
fn(data, e->right.sym, e->right.sym->name);
|
||||
break;
|
||||
case E_LEQ:
|
||||
case E_LTH:
|
||||
if (e->left.sym->name)
|
||||
fn(data, e->left.sym, e->left.sym->name);
|
||||
else
|
||||
fn(data, NULL, "<choice>");
|
||||
fn(data, NULL, e->type == E_LEQ ? "<=" : "<");
|
||||
fn(data, e->right.sym, e->right.sym->name);
|
||||
break;
|
||||
case E_GEQ:
|
||||
case E_GTH:
|
||||
if (e->left.sym->name)
|
||||
fn(data, e->left.sym, e->left.sym->name);
|
||||
else
|
||||
fn(data, NULL, "<choice>");
|
||||
fn(data, NULL, e->type == E_GEQ ? ">=" : ">");
|
||||
fn(data, e->right.sym, e->right.sym->name);
|
||||
break;
|
||||
case E_UNEQUAL:
|
||||
if (e->left.sym->name)
|
||||
fn(data, e->left.sym, e->left.sym->name);
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue