type_qualifiers_t qualifiers = TYPE_QUALIFIER_NONE;
type_modifiers_t modifiers = TYPE_MODIFIER_NONE;
unsigned type_specifiers = 0;
- int newtype = 0;
+ bool newtype = false;
specifiers->source_position = token.source_position;
case SPECIFIER_UNSIGNED | SPECIFIER_LONG | SPECIFIER_INT:
atomic_type = ATOMIC_TYPE_ULONG;
break;
+
case SPECIFIER_LONG | SPECIFIER_LONG_LONG:
case SPECIFIER_SIGNED | SPECIFIER_LONG | SPECIFIER_LONG_LONG:
case SPECIFIER_LONG | SPECIFIER_LONG_LONG | SPECIFIER_INT:
case SPECIFIER_SIGNED | SPECIFIER_LONG | SPECIFIER_LONG_LONG
| SPECIFIER_INT:
atomic_type = ATOMIC_TYPE_LONGLONG;
- break;
+ goto warn_about_long_long;
+
case SPECIFIER_UNSIGNED | SPECIFIER_LONG | SPECIFIER_LONG_LONG:
case SPECIFIER_UNSIGNED | SPECIFIER_LONG | SPECIFIER_LONG_LONG
| SPECIFIER_INT:
atomic_type = ATOMIC_TYPE_ULONGLONG;
+warn_about_long_long:
+ if (warning.long_long) {
+ warningf(&specifiers->source_position,
+ "ISO C90 does not support 'long long'");
+ }
break;
case SPECIFIER_UNSIGNED | SPECIFIER_INT8:
}
} else if ((type_specifiers & SPECIFIER_SIGNED) &&
(type_specifiers & SPECIFIER_UNSIGNED)) {
- errorf(HERE, "signed and unsigned specifiers gives");
+ errorf(HERE, "signed and unsigned specifiers given");
} else if (type_specifiers & (SPECIFIER_SIGNED | SPECIFIER_UNSIGNED)) {
errorf(HERE, "only integer types can be signed or unsigned");
} else {
type = allocate_type_zero(TYPE_ATOMIC, &builtin_source_position);
type->atomic.akind = atomic_type;
}
- newtype = 1;
- } else {
- if (type_specifiers != 0) {
- errorf(HERE, "multiple datatypes in declaration");
- }
+ newtype = true;
+ } else if (type_specifiers != 0) {
+ errorf(HERE, "multiple datatypes in declaration");
}
/* FIXME: check type qualifiers here */
static void semantic_parameter(declaration_t *declaration)
{
/* TODO: improve error messages */
+ source_position_t const* const pos = &declaration->source_position;
- if (declaration->declared_storage_class == STORAGE_CLASS_TYPEDEF) {
- errorf(HERE, "typedef not allowed in parameter list");
- } else if (declaration->declared_storage_class != STORAGE_CLASS_NONE
- && declaration->declared_storage_class != STORAGE_CLASS_REGISTER) {
- errorf(HERE, "parameter may only have none or register storage class");
+ switch (declaration->declared_storage_class) {
+ case STORAGE_CLASS_TYPEDEF:
+ errorf(pos, "typedef not allowed in parameter list");
+ break;
+
+ /* Allowed storage classes */
+ case STORAGE_CLASS_NONE:
+ case STORAGE_CLASS_REGISTER:
+ break;
+
+ default:
+ errorf(pos, "parameter may only have none or register storage class");
+ break;
}
type_t *const orig_type = declaration->type;
declaration->type = type;
if (is_type_incomplete(skip_typeref(type))) {
- errorf(HERE, "incomplete type '%T' not allowed for parameter '%Y'",
+ errorf(pos, "incomplete type '%T' not allowed for parameter '%Y'",
orig_type, declaration->symbol);
}
}
else if (second == NULL) second = "stdcall";
}
if (declaration->modifiers & DM_FASTCALL) {
- if (first == NULL) first = "faslcall";
+ if (first == NULL) first = "fastcall";
else if (second == NULL) second = "fastcall";
}
if (declaration->modifiers & DM_THISCALL) {
construct_type_t *last = NULL;
gnu_attribute_t *attributes = NULL;
- declaration->modifiers |= parse_attributes(&attributes);
+ decl_modifiers_t modifiers = parse_attributes(&attributes);
/* pointers */
while (token.type == '*') {
}
/* TODO: find out if this is correct */
- declaration->modifiers |= parse_attributes(&attributes);
+ modifiers |= parse_attributes(&attributes);
}
+ if (declaration != NULL)
+ declaration->modifiers |= modifiers;
+
construct_type_t *inner_types = NULL;
switch(token.type) {
next_token();
add_anchor_token(')');
inner_types = parse_inner_declarator(declaration, may_be_abstract);
+ /* All later declarators only modify the return type, not declaration */
+ declaration = NULL;
rem_anchor_token(')');
expect(')');
break;
const declaration_specifiers_t *specifiers, bool may_be_abstract)
{
declaration_t *const declaration = allocate_declaration_zero();
+ declaration->source_position = specifiers->source_position;
declaration->declared_storage_class = specifiers->declared_storage_class;
declaration->modifiers = specifiers->modifiers;
declaration->deprecated_string = specifiers->deprecated_string;
const symbol_t *const symbol = declaration->symbol;
const namespace_t namespc = (namespace_t)declaration->namespc;
- assert(declaration->symbol != NULL);
+ assert(symbol != NULL);
declaration_t *previous_declaration = get_declaration(symbol, namespc);
type_t *const orig_type = declaration->type;
check_type_of_main(declaration, &type->function);
}
+ if (warning.nested_externs &&
+ declaration->storage_class == STORAGE_CLASS_EXTERN &&
+ scope != global_scope) {
+ warningf(&declaration->source_position,
+ "nested extern declaration of '%#T'", declaration->type, symbol);
+ }
+
assert(declaration != previous_declaration);
if (previous_declaration != NULL
&& previous_declaration->parent_scope == scope) {
-1;
}
+static bool noreturn_candidate;
+
static void check_reachable(statement_t *const stmt)
{
if (stmt->base.reachable)
break;
case STATEMENT_RETURN:
+ noreturn_candidate = false;
return;
case STATEMENT_IF: {
case STATEMENT_WHILE:
case STATEMENT_DO_WHILE:
case STATEMENT_FOR:
+ last = parent;
next = parent->base.next;
goto found_break_parent;
while (next == NULL) {
next = last->base.parent;
if (next == NULL) {
+ noreturn_candidate = false;
+
type_t *const type = current_function->type;
assert(is_type_function(type));
type_t *const ret = skip_typeref(type->function.return_type);
if (warning.return_type &&
!is_type_atomic(ret, ATOMIC_TYPE_VOID) &&
+ is_type_valid(ret) &&
!is_sym_main(current_function->symbol)) {
warningf(&stmt->base.source_position,
"control reaches end of non-void function");
stmt->kind != STATEMENT_COMPOUND &&
stmt->kind != STATEMENT_DO_WHILE &&
stmt->kind != STATEMENT_FOR) {
- warningf(&stmt->base.source_position,
- "statement is unreachable");
+ warningf(&stmt->base.source_position, "statement is unreachable");
}
switch (stmt->kind) {
case STATEMENT_FOR: {
for_statement_t const* const fors = &stmt->fors;
- if (!stmt->base.reachable && fors->initialisation != NULL) {
- warningf(&fors->initialisation->base.source_position,
- "initialisation of for-statement is unreachable");
- }
+ // if init and step are unreachable, cond is unreachable, too
+ if (!stmt->base.reachable && !fors->step_reachable) {
+ warningf(&stmt->base.source_position, "statement is unreachable");
+ } else {
+ if (!stmt->base.reachable && fors->initialisation != NULL) {
+ warningf(&fors->initialisation->base.source_position,
+ "initialisation of for-statement is unreachable");
+ }
- if (!fors->condition_reachable && fors->condition != NULL) {
- warningf(&fors->condition->base.source_position,
- "condition of for-statement is unreachable");
- }
+ if (!fors->condition_reachable && fors->condition != NULL) {
+ warningf(&fors->condition->base.source_position,
+ "condition of for-statement is unreachable");
+ }
- if (!fors->step_reachable && fors->step != NULL) {
- warningf(&fors->step->base.source_position,
- "step of for-statement is unreachable");
+ if (!fors->step_reachable && fors->step != NULL) {
+ warningf(&fors->step->base.source_position,
+ "step of for-statement is unreachable");
+ }
}
check_unreachable(stmt->fors.body);
|| parameter->parent_scope == scope);
parameter->parent_scope = scope;
if (parameter->symbol == NULL) {
- errorf(&ndeclaration->source_position, "parameter name omitted");
+ errorf(¶meter->source_position, "parameter name omitted");
continue;
}
environment_push(parameter);
first_err = true;
check_labels();
check_declarations();
- if (warning.return_type || warning.unreachable_code) {
+ if (warning.return_type ||
+ warning.unreachable_code ||
+ (warning.missing_noreturn && !(declaration->modifiers & DM_NORETURN))) {
+ noreturn_candidate = true;
check_reachable(body);
if (warning.unreachable_code)
check_unreachable(body);
+ if (warning.missing_noreturn &&
+ noreturn_candidate &&
+ !(declaration->modifiers & DM_NORETURN)) {
+ warningf(&body->base.source_position,
+ "function '%#T' is candidate for attribute 'noreturn'",
+ type, declaration->symbol);
+ }
}
assert(current_parent == NULL);
static expression_t *parse_conditional_expression(unsigned precedence,
expression_t *expression)
{
- eat('?');
- add_anchor_token(':');
-
expression_t *result = allocate_expression_zero(EXPR_CONDITIONAL);
conditional_expression_t *conditional = &result->conditional;
- conditional->condition = expression;
+ conditional->base.source_position = *HERE;
+ conditional->condition = expression;
+
+ eat('?');
+ add_anchor_token(':');
/* 6.5.15.2 */
type_t *const condition_type_orig = expression->base.type;
is_type_atomic(false_type, ATOMIC_TYPE_VOID)) {
if (!is_type_atomic(true_type, ATOMIC_TYPE_VOID)
|| !is_type_atomic(false_type, ATOMIC_TYPE_VOID)) {
- warningf(&expression->base.source_position,
+ warningf(&conditional->base.source_position,
"ISO C forbids conditional expression with only one void side");
}
result_type = type_void;
get_unqualified_type(to2))) {
to = to1;
} else {
- warningf(&expression->base.source_position,
+ warningf(&conditional->base.source_position,
"pointer types '%T' and '%T' in conditional expression are incompatible",
true_type, false_type);
to = type_void;
result_type = make_pointer_type(type, TYPE_QUALIFIER_NONE);
} else if (is_type_integer(other_type)) {
- warningf(&expression->base.source_position,
+ warningf(&conditional->base.source_position,
"pointer/integer type mismatch in conditional expression ('%T' and '%T')", true_type, false_type);
result_type = pointer_type;
} else {
if (is_type_valid(true_type) && is_type_valid(false_type)) {
type_error_incompatible("while parsing conditional",
- &expression->base.source_position, true_type,
+ &conditional->base.source_position, true_type,
false_type);
}
result_type = type_error_type;
return create_invalid_expression();
}
-static void check_pointer_arithmetic(const source_position_t *source_position,
+static bool check_pointer_arithmetic(const source_position_t *source_position,
type_t *pointer_type,
type_t *orig_pointer_type)
{
errorf(source_position,
"arithmetic with pointer to incomplete type '%T' not allowed",
orig_pointer_type);
+ return false;
} else if (is_type_function(points_to)) {
errorf(source_position,
"arithmetic with pointer to function type '%T' not allowed",
orig_pointer_type);
+ return false;
}
+ return true;
}
static void semantic_incdec(unary_expression_t *expression)
type_t *const orig_type = expression->value->base.type;
type_t *const type = skip_typeref(orig_type);
if (is_type_pointer(type)) {
- check_pointer_arithmetic(&expression->base.source_position,
- type, orig_type);
+ if (!check_pointer_arithmetic(&expression->base.source_position,
+ type, orig_type)) {
+ return;
+ }
} else if (!is_type_real(type) && is_type_valid(type)) {
/* TODO: improve error message */
- errorf(HERE, "operation needs an arithmetic or pointer type");
+ errorf(&expression->base.source_position,
+ "operation needs an arithmetic or pointer type");
+ return;
}
expression->base.type = orig_type;
}
if (!is_type_arithmetic(type)) {
if (is_type_valid(type)) {
/* TODO: improve error message */
- errorf(HERE, "operation needs an arithmetic type");
+ errorf(&expression->base.source_position,
+ "operation needs an arithmetic type");
}
return;
}
expression->base.type = orig_type;
}
-static void semantic_unexpr_scalar(unary_expression_t *expression)
+static void semantic_not(unary_expression_t *expression)
{
type_t *const orig_type = expression->value->base.type;
type_t *const type = skip_typeref(orig_type);
- if (!is_type_scalar(type)) {
- if (is_type_valid(type)) {
- errorf(HERE, "operand of ! must be of scalar type");
- }
- return;
+ if (!is_type_scalar(type) && is_type_valid(type)) {
+ errorf(&expression->base.source_position,
+ "operand of ! must be of scalar type");
}
- expression->base.type = orig_type;
+ expression->base.type = type_int;
}
static void semantic_unexpr_integer(unary_expression_t *expression)
type_t *const type = skip_typeref(orig_type);
if (!is_type_integer(type)) {
if (is_type_valid(type)) {
- errorf(HERE, "operand of ~ must be of integer type");
+ errorf(&expression->base.source_position,
+ "operand of ~ must be of integer type");
}
return;
}
type_t *const type = skip_typeref(orig_type);
if (!is_type_pointer(type)) {
if (is_type_valid(type)) {
- errorf(HERE, "Unary '*' needs pointer or arrray type, but type '%T' given", orig_type);
+ errorf(&expression->base.source_position,
+ "Unary '*' needs pointer or arrray type, but type '%T' given", orig_type);
}
return;
}
#define CREATE_UNARY_EXPRESSION_PARSER(token_type, unexpression_type, sfunc) \
static expression_t *parse_##unexpression_type(unsigned precedence) \
{ \
- eat(token_type); \
- \
expression_t *unary_expression \
= allocate_expression_zero(unexpression_type); \
unary_expression->base.source_position = *HERE; \
+ eat(token_type); \
unary_expression->unary.value = parse_sub_expression(precedence); \
\
sfunc(&unary_expression->unary); \
CREATE_UNARY_EXPRESSION_PARSER('+', EXPR_UNARY_PLUS,
semantic_unexpr_arithmetic)
CREATE_UNARY_EXPRESSION_PARSER('!', EXPR_UNARY_NOT,
- semantic_unexpr_scalar)
+ semantic_not)
CREATE_UNARY_EXPRESSION_PARSER('*', EXPR_UNARY_DEREFERENCE,
semantic_dereference)
CREATE_UNARY_EXPRESSION_PARSER('&', EXPR_UNARY_TAKE_ADDRESS,
expression_t *left) \
{ \
(void) precedence; \
- eat(token_type); \
\
expression_t *unary_expression \
= allocate_expression_zero(unexpression_type); \
- unary_expression->unary.value = left; \
+ unary_expression->base.source_position = *HERE; \
+ eat(token_type); \
+ unary_expression->unary.value = left; \
\
sfunc(&unary_expression->unary); \
\
if (get_atomic_type_size(s_rank) > get_atomic_type_size(u_rank))
return s_type;
- /* FIXME ugly */
- type_t *const type = allocate_type_zero(TYPE_ATOMIC, &builtin_source_position);
switch (s_rank) {
- case ATOMIC_TYPE_INT: type->atomic.akind = ATOMIC_TYPE_UINT; break;
- case ATOMIC_TYPE_LONG: type->atomic.akind = ATOMIC_TYPE_ULONG; break;
- case ATOMIC_TYPE_LONGLONG: type->atomic.akind = ATOMIC_TYPE_ULONGLONG; break;
+ case ATOMIC_TYPE_INT: return type_int;
+ case ATOMIC_TYPE_LONG: return type_long;
+ case ATOMIC_TYPE_LONGLONG: return type_long_long;
default: panic("invalid atomic type");
}
-
- type_t* const result = typehash_insert(type);
- if (result != type)
- free_type(type);
-
- return result;
}
/**
if (!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "operation needs arithmetic types");
+ errorf(&expression->base.source_position,
+ "operation needs arithmetic types");
}
return;
}
if (!is_type_integer(type_left) || !is_type_integer(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "operation needs integer types");
+ errorf(&expression->base.source_position,
+ "operands of shift operation must have integer types");
}
return;
}
static void semantic_sub(binary_expression_t *expression)
{
- expression_t *const left = expression->left;
- expression_t *const right = expression->right;
- type_t *const orig_type_left = left->base.type;
- type_t *const orig_type_right = right->base.type;
- type_t *const type_left = skip_typeref(orig_type_left);
- type_t *const type_right = skip_typeref(orig_type_right);
+ expression_t *const left = expression->left;
+ expression_t *const right = expression->right;
+ type_t *const orig_type_left = left->base.type;
+ type_t *const orig_type_right = right->base.type;
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
+ source_position_t const *const pos = &expression->base.source_position;
/* ยง 5.6.5 */
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
type_t *const unqual_left = get_unqualified_type(skip_typeref(type_left->pointer.points_to));
type_t *const unqual_right = get_unqualified_type(skip_typeref(type_right->pointer.points_to));
if (!types_compatible(unqual_left, unqual_right)) {
- errorf(&expression->base.source_position,
+ errorf(pos,
"subtracting pointers to incompatible types '%T' and '%T'",
orig_type_left, orig_type_right);
} else if (!is_type_object(unqual_left)) {
if (is_type_atomic(unqual_left, ATOMIC_TYPE_VOID)) {
- warningf(&expression->base.source_position,
- "subtracting pointers to void");
+ warningf(pos, "subtracting pointers to void");
} else {
- errorf(&expression->base.source_position,
- "subtracting pointers to non-object types '%T'",
+ errorf(pos, "subtracting pointers to non-object types '%T'",
orig_type_left);
}
}
expression->base.type = type_ptrdiff_t;
} else if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "invalid operands of types '%T' and '%T' to binary '-'",
+ errorf(pos, "invalid operands of types '%T' and '%T' to binary '-'",
orig_type_left, orig_type_right);
}
}
if (!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "operation needs arithmetic types");
+ errorf(&expression->base.source_position,
+ "operation needs arithmetic types");
}
return;
}
type_left, orig_type_left);
expression->base.type = type_left;
} else if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "incompatible types '%T' and '%T' in assignment", orig_type_left, orig_type_right);
+ errorf(&expression->base.source_position,
+ "incompatible types '%T' and '%T' in assignment",
+ orig_type_left, orig_type_right);
}
}
if (!is_type_scalar(type_left) || !is_type_scalar(type_right)) {
/* TODO: improve error message */
if (is_type_valid(type_left) && is_type_valid(type_right)) {
- errorf(HERE, "operation needs scalar types");
+ errorf(&expression->base.source_position,
+ "operation needs scalar types");
}
return;
}
static expression_t *parse_##binexpression_type(unsigned precedence, \
expression_t *left) \
{ \
+ expression_t *binexpr = allocate_expression_zero(binexpression_type); \
+ binexpr->base.source_position = *HERE; \
+ binexpr->binary.left = left; \
eat(token_type); \
- source_position_t pos = *HERE; \
\
expression_t *right = parse_sub_expression(precedence + lr); \
\
- expression_t *binexpr = allocate_expression_zero(binexpression_type); \
- binexpr->base.source_position = pos; \
- binexpr->binary.left = left; \
binexpr->binary.right = right; \
sfunc(&binexpr->binary); \
\
if (e == NULL || !is_constant_expression(e) || fold_constant(e) != val)
continue;
- errorf(pos, "duplicate case value");
- errorf(&l->base.source_position, "previously used here");
+ errorf(pos, "duplicate case value (previously used %P)",
+ &l->base.source_position);
break;
}
statement_t *last_statement = NULL;
+ bool only_decls_so_far = true;
while (token.type != '}' && token.type != T_EOF) {
statement_t *sub_statement = intern_parse_statement();
if (is_invalid_statement(sub_statement)) {
continue;
}
+ if (warning.declaration_after_statement) {
+ if (sub_statement->kind != STATEMENT_DECLARATION) {
+ only_decls_so_far = false;
+ } else if (!only_decls_so_far) {
+ warningf(&sub_statement->base.source_position,
+ "ISO C90 forbids mixed declarations and code");
+ }
+ }
+
if (last_statement != NULL) {
last_statement->base.next = sub_statement;
} else {
projects / cparser / blobdiff