Adding a new function expression_error, it works just like
sparse_error but it also install a bad_ctype on expression.
Signed-Off-By: Christopher Li <[EMAIL PROTECTED]>
Index: sparse/lib.c
===================================================================
--- sparse.orig/lib.c 2007-02-26 03:31:23.000000000 -0800
+++ sparse/lib.c 2007-02-27 01:04:19.000000000 -0800
@@ -126,10 +126,9 @@ void warning(struct position pos, const
va_end(args);
}
-void sparse_error(struct position pos, const char * fmt, ...)
+void do_error(struct position pos, const char * fmt, va_list args)
{
static int errors = 0;
- va_list args;
die_if_error = 1;
show_info = 1;
/* Shut up warnings after an error */
@@ -143,12 +142,27 @@ void sparse_error(struct position pos, c
once = 1;
}
- va_start(args, fmt);
do_warn("error: ", pos, fmt, args);
- va_end(args);
errors++;
}
+void sparse_error(struct position pos, const char * fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ do_error(pos, fmt, args);
+ va_end(args);
+}
+
+void expression_error(struct expression *expr, const char *fmt, ...)
+{
+ va_list args;
+ va_start(args, fmt);
+ do_error(expr->pos, fmt, args);
+ va_end(args);
+ expr->ctype = &bad_ctype;
+}
+
void error_die(struct position pos, const char * fmt, ...)
{
va_list args;
Index: sparse/evaluate.c
===================================================================
--- sparse.orig/evaluate.c 2007-02-26 03:31:23.000000000 -0800
+++ sparse/evaluate.c 2007-02-27 01:12:46.000000000 -0800
@@ -38,7 +38,7 @@ static struct symbol *evaluate_symbol_ex
struct symbol *base_type;
if (!sym) {
- sparse_error(expr->pos, "undefined identifier '%s'",
show_ident(expr->symbol_name));
+ expression_error(expr, "undefined identifier '%s'",
show_ident(expr->symbol_name));
return NULL;
}
@@ -46,7 +46,7 @@ static struct symbol *evaluate_symbol_ex
base_type = get_base_type(sym);
if (!base_type) {
- sparse_error(expr->pos, "identifier '%s' has no type",
show_ident(expr->symbol_name));
+ expression_error(expr, "identifier '%s' has no type",
show_ident(expr->symbol_name));
return NULL;
}
@@ -597,7 +597,7 @@ static struct symbol *evaluate_ptr_add(s
examine_symbol_type(ctype);
if (!ctype->ctype.base_type) {
- sparse_error(expr->pos, "missing type information");
+ expression_error(expr, "missing type information");
return NULL;
}
@@ -855,7 +855,7 @@ static struct symbol *evaluate_ptr_sub(s
if (typediff) {
ctype = common_ptr_type(l, r);
if (!ctype) {
- sparse_error(expr->pos, "subtraction of different types
can't work (%s)", typediff);
+ expression_error(expr, "subtraction of different types
can't work (%s)", typediff);
return NULL;
}
}
@@ -865,7 +865,7 @@ static struct symbol *evaluate_ptr_sub(s
if (ctype->type == SYM_NODE)
ctype = ctype->ctype.base_type;
if (ctype->type != SYM_PTR && ctype->type != SYM_ARRAY) {
- sparse_error(expr->pos, "subtraction of functions? Share your
drugs");
+ expression_error(expr, "subtraction of functions? Share your
drugs");
return NULL;
}
ctype = get_base_type(ctype);
@@ -1106,7 +1106,7 @@ static struct symbol *evaluate_condition
typediff = type_difference(ltype, rtype, MOD_IGN, MOD_IGN);
if (!typediff)
goto out;
- sparse_error(expr->pos, "incompatible types in conditional expression
(%s)", typediff);
+ expression_error(expr, "incompatible types in conditional expression
(%s)", typediff);
return NULL;
out:
@@ -1135,12 +1135,12 @@ static int compatible_assignment_types(s
if (tclass & sclass & TYPE_NUM) {
if (tclass & TYPE_FLOAT && !compatible_float_op(op)) {
- sparse_error(expr->pos, "invalid assignment");
+ expression_error(expr, "invalid assignment");
return 0;
}
if (tclass & TYPE_RESTRICT) {
if (!restricted_binop(op, target)) {
- sparse_error(expr->pos, "bad restricted
assignment");
+ expression_error(expr, "bad restricted
assignment");
return 0;
}
/* allowed assignments unfoul */
@@ -1156,11 +1156,11 @@ static int compatible_assignment_types(s
return 1;
}
if (op != '=') {
- sparse_error(expr->pos, "invalid pointer assignment");
+ expression_error(expr, "invalid pointer assignment");
return 0;
}
} else if (op != '=') {
- sparse_error(expr->pos, "invalid assignment");
+ expression_error(expr, "invalid assignment");
return 0;
}
@@ -1234,7 +1234,7 @@ static void mark_assigned(struct express
static void evaluate_assign_to(struct expression *left, struct symbol *type)
{
if (type->ctype.modifiers & MOD_CONST)
- sparse_error(left->pos, "assignment to const expression");
+ expression_error(left, "assignment to const expression");
/* We know left is an lvalue, so it's a "preop-*" */
mark_assigned(left->unop);
@@ -1247,7 +1247,7 @@ static struct symbol *evaluate_assignmen
struct symbol *ltype, *rtype;
if (!lvalue_expression(left)) {
- sparse_error(expr->pos, "not an lvalue");
+ expression_error(expr, "not an lvalue");
return NULL;
}
@@ -1412,7 +1412,7 @@ static struct symbol *degenerate(struct
}
case SYM_FN:
if (expr->op != '*' || expr->type != EXPR_PREOP) {
- sparse_error(expr->pos, "strange non-value function or
array");
+ expression_error(expr, "strange non-value function or
array");
return &bad_ctype;
}
*expr = *expr->unop;
@@ -1430,7 +1430,7 @@ static struct symbol *evaluate_addressof
struct symbol *ctype;
if (op->op != '*' || op->type != EXPR_PREOP) {
- sparse_error(expr->pos, "not addressable");
+ expression_error(expr, "not addressable");
return NULL;
}
ctype = op->ctype;
@@ -1474,7 +1474,7 @@ static struct symbol *evaluate_dereferen
switch (ctype->type) {
default:
- sparse_error(expr->pos, "cannot dereference this type");
+ expression_error(expr, "cannot dereference this type");
return NULL;
case SYM_PTR:
node->ctype.modifiers = target->ctype.modifiers & MOD_SPECIFIER;
@@ -1483,7 +1483,7 @@ static struct symbol *evaluate_dereferen
case SYM_ARRAY:
if (!lvalue_expression(op)) {
- sparse_error(op->pos, "non-lvalue array??");
+ expression_error(op, "non-lvalue array??");
return NULL;
}
@@ -1515,14 +1515,14 @@ static struct symbol *evaluate_postop(st
struct symbol *ctype = op->ctype;
if (!lvalue_expression(expr->unop)) {
- sparse_error(expr->pos, "need lvalue expression for ++/--");
+ expression_error(expr, "need lvalue expression for ++/--");
return NULL;
}
if (is_restricted_type(ctype) && restricted_unop(expr->op, &ctype)) {
- sparse_error(expr->pos, "bad operation on restricted");
+ expression_error(expr, "bad operation on restricted");
return NULL;
} else if (is_fouled_type(ctype) && restricted_unop(expr->op, &ctype)) {
- sparse_error(expr->pos, "bad operation on restricted");
+ expression_error(expr, "bad operation on restricted");
return NULL;
}
@@ -1685,7 +1685,7 @@ static struct symbol *evaluate_member_de
if (!evaluate_expression(deref))
return NULL;
if (!ident) {
- sparse_error(expr->pos, "bad member name");
+ expression_error(expr, "bad member name");
return NULL;
}
@@ -1698,7 +1698,7 @@ static struct symbol *evaluate_member_de
mod |= ctype->ctype.modifiers;
}
if (!ctype || (ctype->type != SYM_STRUCT && ctype->type != SYM_UNION)) {
- sparse_error(expr->pos, "expected structure or union");
+ expression_error(expr, "expected structure or union");
return NULL;
}
examine_symbol_type(ctype);
@@ -1712,7 +1712,7 @@ static struct symbol *evaluate_member_de
name = ctype->ident->name;
namelen = ctype->ident->len;
}
- sparse_error(expr->pos, "no member '%s' in %s %.*s",
+ expression_error(expr, "no member '%s' in %s %.*s",
show_ident(ident), type, namelen, name);
return NULL;
}
@@ -1804,7 +1804,7 @@ static struct symbol *evaluate_type_info
}
examine_symbol_type(sym);
if (is_bitfield_type(sym)) {
- sparse_error(expr->pos, "trying to examine bitfield type");
+ expression_error(expr, "trying to examine bitfield type");
return NULL;
}
return sym;
@@ -1821,7 +1821,7 @@ static struct symbol *evaluate_sizeof(st
size = type->bit_size;
if ((size < 0) || (size & 7))
- sparse_error(expr->pos, "cannot size expression");
+ expression_error(expr, "cannot size expression");
expr->type = EXPR_VALUE;
expr->value = size >> 3;
expr->ctype = size_t_ctype;
@@ -1849,7 +1849,7 @@ static struct symbol *evaluate_ptrsizeof
if (type)
break;
default:
- sparse_error(expr->pos, "expected pointer expression");
+ expression_error(expr, "expected pointer expression");
return NULL;
}
size = type->bit_size;
@@ -1968,7 +1968,7 @@ static void evaluate_array_initializer(s
static void evaluate_scalar_initializer(struct symbol *ctype, struct
expression *expr)
{
if (expression_list_size(expr->expr_list) != 1) {
- sparse_error(expr->pos, "unexpected compound initializer");
+ expression_error(expr, "unexpected compound initializer");
return;
}
evaluate_array_initializer(ctype, expr);
@@ -1994,7 +1994,7 @@ static int evaluate_one_struct_initializ
unsigned long offset;
if (!sym) {
- sparse_error(entry->pos, "unknown named initializer");
+ expression_error(entry, "unknown named initializer");
return -1;
}
@@ -2103,7 +2103,7 @@ static void evaluate_initializer(struct
if (ctype->type == SYM_NODE)
ctype = ctype->ctype.base_type;
if (ctype->type != SYM_STRUCT && ctype->type != SYM_UNION) {
- sparse_error(expr->pos, "expected structure or union
for '%s' dereference", show_ident(expr->expr_ident));
+ expression_error(expr, "expected structure or union for
'%s' dereference", show_ident(expr->expr_ident));
show_symbol(ctype);
return;
}
@@ -2115,7 +2115,7 @@ static void evaluate_initializer(struct
if (ctype->type == SYM_NODE)
ctype = ctype->ctype.base_type;
if (ctype->type != SYM_ARRAY) {
- sparse_error(expr->pos, "expected array");
+ expression_error(expr, "expected array");
return;
}
evaluate_one_array_initializer(ctype->ctype.base_type, ep, 0);
@@ -2247,7 +2247,7 @@ static struct symbol *evaluate_cast(stru
t2 = target->ctype;
if (!t2) {
- sparse_error(expr->pos, "cast from unknown type");
+ expression_error(expr, "cast from unknown type");
goto out;
}
class2 = classify_type(t2, &t2);
@@ -2342,18 +2342,18 @@ static struct symbol *evaluate_call(stru
if (!evaluate_arguments(sym, ctype, arglist))
return NULL;
if (ctype->type != SYM_FN) {
- sparse_error(expr->pos, "not a function %s",
+ expression_error(expr, "not a function %s",
show_ident(sym->ident));
return NULL;
}
args = expression_list_size(expr->args);
fnargs = symbol_list_size(ctype->arguments);
if (args < fnargs)
- sparse_error(expr->pos,
+ expression_error(expr,
"not enough arguments for function %s",
show_ident(sym->ident));
if (args > fnargs && !ctype->variadic)
- sparse_error(expr->pos,
+ expression_error(expr,
"too many arguments for function %s",
show_ident(sym->ident));
}
@@ -2375,7 +2375,7 @@ struct symbol *evaluate_expression(struc
switch (expr->type) {
case EXPR_VALUE:
case EXPR_FVALUE:
- sparse_error(expr->pos, "value expression without a type");
+ expression_error(expr, "value expression without a type");
return NULL;
case EXPR_STRING:
return evaluate_string(expr);
@@ -2450,10 +2450,10 @@ struct symbol *evaluate_expression(struc
case EXPR_IDENTIFIER:
case EXPR_INDEX:
case EXPR_POS:
- sparse_error(expr->pos, "internal front-end error: initializer
in expression");
+ expression_error(expr, "internal front-end error: initializer
in expression");
return NULL;
case EXPR_SLICE:
- sparse_error(expr->pos, "internal front-end error: SLICE
re-evaluated");
+ expression_error(expr, "internal front-end error: SLICE
re-evaluated");
return NULL;
}
return NULL;
@@ -2547,7 +2547,7 @@ static struct symbol *evaluate_return_ex
fntype = current_fn->ctype.base_type;
if (!fntype || fntype == &void_ctype) {
if (expr && ctype != &void_ctype)
- sparse_error(expr->pos, "return expression in %s
function", fntype?"void":"typeless");
+ expression_error(expr, "return expression in %s
function", fntype?"void":"typeless");
return NULL;
}
@@ -2587,7 +2587,7 @@ static void verify_output_constraint(str
case '+': /* Update */
break;
default:
- sparse_error(expr->pos, "output constraint is not an assignment
constraint (\"%s\")", constraint);
+ expression_error(expr, "output constraint is not an assignment
constraint (\"%s\")", constraint);
}
}
@@ -2596,7 +2596,7 @@ static void verify_input_constraint(stru
switch (*constraint) {
case '=': /* Assignment */
case '+': /* Update */
- sparse_error(expr->pos, "input constraint with assignment
(\"%s\")", constraint);
+ expression_error(expr, "input constraint with assignment
(\"%s\")", constraint);
}
}
@@ -2677,7 +2677,7 @@ static void evaluate_asm_statement(struc
}
if (expr->type == EXPR_STRING)
continue;
- sparse_error(expr->pos, "asm clobber is not a string");
+ expression_error(expr, "asm clobber is not a string");
} END_FOR_EACH_PTR(expr);
}
@@ -2732,7 +2732,7 @@ static void check_case_type(struct expre
return;
Bad:
- sparse_error(case_expr->pos, "incompatible types for 'case' statement");
+ expression_error(case_expr, "incompatible types for 'case' statement");
}
static void evaluate_switch_statement(struct statement *stmt)
Index: sparse/expand.c
===================================================================
--- sparse.orig/expand.c 2007-02-26 03:31:23.000000000 -0800
+++ sparse/expand.c 2007-02-27 01:04:49.000000000 -0800
@@ -765,7 +765,7 @@ static int expand_call(struct expression
cost = expand_arguments(expr->args);
sym = fn->ctype;
if (!sym) {
- sparse_error(expr->pos, "function has no type");
+ expression_error(expr, "function has no type");
return SIDE_EFFECTS;
}
if (sym->type == SYM_NODE)
@@ -964,7 +964,7 @@ static int expand_expression(struct expr
case EXPR_SIZEOF:
case EXPR_PTRSIZEOF:
case EXPR_ALIGNOF:
- sparse_error(expr->pos, "internal front-end error: sizeof in
expansion?");
+ expression_error(expr, "internal front-end error: sizeof in
expansion?");
return UNSAFE;
}
return SIDE_EFFECTS;
@@ -975,7 +975,7 @@ static void expand_const_expression(stru
if (expr) {
expand_expression(expr);
if (expr->type != EXPR_VALUE)
- sparse_error(expr->pos, "Expected constant expression
in %s", where);
+ expression_error(expr, "Expected constant expression in
%s", where);
}
}
@@ -1148,12 +1148,12 @@ long long get_expression_value(struct ex
return 0;
ctype = evaluate_expression(expr);
if (!ctype) {
- sparse_error(expr->pos, "bad constant expression type");
+ expression_error(expr, "bad constant expression type");
return 0;
}
expand_expression(expr);
if (expr->type != EXPR_VALUE) {
- sparse_error(expr->pos, "bad constant expression");
+ expression_error(expr, "bad constant expression");
return 0;
}
Index: sparse/lib.h
===================================================================
--- sparse.orig/lib.h 2007-02-26 03:31:23.000000000 -0800
+++ sparse/lib.h 2007-02-27 01:16:07.000000000 -0800
@@ -76,6 +76,7 @@ extern void info(struct position, const
extern void warning(struct position, const char *, ...) FORMAT_ATTR(2);
extern void sparse_error(struct position, const char *, ...) FORMAT_ATTR(2);
extern void error_die(struct position, const char *, ...) FORMAT_ATTR(2);
+extern void expression_error(struct expression *, const char *, ...)
FORMAT_ATTR(2);
#undef FORMAT_ATTR
extern char **handle_switch(char *arg, char **next);
-
To unsubscribe from this list: send the line "unsubscribe linux-sparse" in
the body of a message to [EMAIL PROTECTED]
More majordomo info at http://vger.kernel.org/majordomo-info.html
