case T_union: \
case T_unsigned: \
case T_void: \
+ case T_wchar_t: \
COMPLEX_SPECIFIERS \
IMAGINARY_SPECIFIERS
* If not, generate an error, eat the current statement,
* and goto the end_error label.
*/
-#define expect(expected) \
+#define expect(expected, error_label) \
do { \
if (UNLIKELY(token.type != (expected))) { \
parse_error_expected(NULL, (expected), NULL); \
if (token.type == expected) \
next_token(); \
rem_anchor_token(expected); \
- goto end_error; \
+ goto error_label; \
} \
next_token(); \
} while (0)
add_anchor_token(')');
expression = parse_constant_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
attribute->u.argument = fold_constant(expression);
return;
end_error:
}
rem_anchor_token(',');
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
return;
end_error:
attribute->invalid = true;
}
*string = parse_string_literals();
rem_anchor_token('(');
- expect(')');
+ expect(')', end_error);
return;
end_error:
attribute->invalid = true;
add_anchor_token(')');
if (token.type != T_IDENTIFIER) {
- expect(T_IDENTIFIER);
+ expect(T_IDENTIFIER, end_error);
}
/* This isn't really correct, the backend should provide a list of machine
next_token();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
return;
end_error:
attribute->invalid = true;
}
next_token();
- expect(',');
+ expect(',', end_error);
add_anchor_token(')');
add_anchor_token(',');
parse_constant_expression();
rem_anchor_token(',');
rem_anchor_token(')');
- expect(',');
+ expect(',', end_error);
add_anchor_token(')');
parse_constant_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
return;
end_error:
attribute->u.value = true;
gnu_attribute_t *attribute;
eat(T___attribute__);
- expect('(');
- expect('(');
+ expect('(', end_error);
+ expect('(', end_error);
if (token.type != ')') {
/* find the end of the list */
next_token();
}
}
- expect(')');
- expect(')');
+ expect(')', end_error);
+ expect(')', end_error);
end_error:
*attributes = head;
case T_asm:
next_token();
- expect('(');
+ expect('(', end_error);
if (token.type != T_STRING_LITERAL) {
parse_error_expected("while parsing assembler attribute",
T_STRING_LITERAL, NULL);
} else {
parse_string_literals();
}
- expect(')');
+ expect(')', end_error);
continue;
case T_cdecl: modifiers |= DM_CDECL; break;
add_anchor_token(']');
designator->array_index = parse_constant_expression();
rem_anchor_token(']');
- expect(']');
+ expect(']', end_error);
break;
case '.':
designator = allocate_ast_zero(sizeof(designator[0]));
next_token();
break;
default:
- expect('=');
+ expect('=', end_error);
return result;
}
if (type != NULL) {
ascend_from_subtype(path);
- expect('}');
+ expect('}', end_error);
} else {
- expect('}');
+ expect('}', end_error);
goto error_parse_next;
}
}
if (token.type == '}') {
break;
}
- expect(',');
+ expect(',', end_error);
if (token.type == '}') {
break;
}
max_index = path.max_index;
DEL_ARR_F(path.path);
- expect('}');
+ expect('}', end_error);
} else {
/* parse_scalar_initializer() also works in this case: we simply
* have an expression without {} around it */
} while (token.type != '}');
rem_anchor_token('}');
- expect('}');
+ expect('}', end_error);
end_error:
;
type_t *type;
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *expression = NULL;
in_gcc_extension = old_gcc_extension;
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
type_t *typeof_type = allocate_type_zero(TYPE_TYPEOF);
typeof_type->typeoft.expression = expression;
SPECIFIER_INT = 1 << 3,
SPECIFIER_DOUBLE = 1 << 4,
SPECIFIER_CHAR = 1 << 5,
- SPECIFIER_SHORT = 1 << 6,
- SPECIFIER_LONG_LONG = 1 << 7,
- SPECIFIER_FLOAT = 1 << 8,
- SPECIFIER_BOOL = 1 << 9,
- SPECIFIER_VOID = 1 << 10,
- SPECIFIER_INT8 = 1 << 11,
- SPECIFIER_INT16 = 1 << 12,
- SPECIFIER_INT32 = 1 << 13,
- SPECIFIER_INT64 = 1 << 14,
- SPECIFIER_INT128 = 1 << 15,
- SPECIFIER_COMPLEX = 1 << 16,
- SPECIFIER_IMAGINARY = 1 << 17,
+ SPECIFIER_WCHAR_T = 1 << 6,
+ SPECIFIER_SHORT = 1 << 7,
+ SPECIFIER_LONG_LONG = 1 << 8,
+ SPECIFIER_FLOAT = 1 << 9,
+ SPECIFIER_BOOL = 1 << 10,
+ SPECIFIER_VOID = 1 << 11,
+ SPECIFIER_INT8 = 1 << 12,
+ SPECIFIER_INT16 = 1 << 13,
+ SPECIFIER_INT32 = 1 << 14,
+ SPECIFIER_INT64 = 1 << 15,
+ SPECIFIER_INT128 = 1 << 16,
+ SPECIFIER_COMPLEX = 1 << 17,
+ SPECIFIER_IMAGINARY = 1 << 18,
} specifiers_t;
static type_t *create_builtin_type(symbol_t *const symbol,
symbol_t *symbol = token.v.symbol;
if (symbol == sym_align) {
next_token();
- expect('(');
+ expect('(', end_error);
if (token.type != T_INTEGER)
goto end_error;
if (check_alignment_value(token.v.intvalue)) {
specifiers->alignment = (unsigned char)token.v.intvalue;
}
next_token();
- expect(')');
+ expect(')', end_error);
} else if (symbol == sym_allocate) {
next_token();
- expect('(');
+ expect('(', end_error);
if (token.type != T_IDENTIFIER)
goto end_error;
(void)token.v.symbol;
- expect(')');
+ expect(')', end_error);
} else if (symbol == sym_dllimport) {
next_token();
DET_MOD(dllimport, DM_DLLIMPORT);
DET_MOD(novtable, DM_NOVTABLE);
} else if (symbol == sym_property) {
next_token();
- expect('(');
+ expect('(', end_error);
for (;;) {
bool is_get = false;
if (token.type != T_IDENTIFIER)
goto end_error;
}
next_token();
- expect('=');
+ expect('=', end_error);
if (token.type != T_IDENTIFIER)
goto end_error;
if (is_get) {
}
break;
}
- expect(')');
+ expect(')', end_error);
} else if (symbol == sym_selectany) {
next_token();
DET_MOD(selectany, DM_SELECTANY);
} else if (symbol == sym_uuid) {
next_token();
- expect('(');
+ expect('(', end_error);
if (token.type != T_STRING_LITERAL)
goto end_error;
next_token();
- expect(')');
+ expect(')', end_error);
} else if (symbol == sym_deprecated) {
next_token();
if (specifiers->deprecated != 0 && warning.other)
} else {
errorf(HERE, "string literal expected");
}
- expect(')');
+ expect(')', end_error);
}
} else if (symbol == sym_noalias) {
next_token();
case T__declspec:
next_token();
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
parse_microsoft_extended_decl_modifier(specifiers);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
break;
case T___thread:
MATCH_SPECIFIER(T_signed, SPECIFIER_SIGNED, "signed");
MATCH_SPECIFIER(T_unsigned, SPECIFIER_UNSIGNED, "unsigned");
MATCH_SPECIFIER(T_void, SPECIFIER_VOID, "void");
+ MATCH_SPECIFIER(T_wchar_t, SPECIFIER_WCHAR_T, "wchar_t");
case T__forceinline:
/* only in microsoft mode */
case SPECIFIER_VOID:
atomic_type = ATOMIC_TYPE_VOID;
break;
+ case SPECIFIER_WCHAR_T:
+ atomic_type = ATOMIC_TYPE_WCHAR_T;
+ break;
case SPECIFIER_CHAR:
atomic_type = ATOMIC_TYPE_CHAR;
break;
/* a K&R parameter has no type, yet */
next_token();
- append_entity(scope, entity);
+ if (scope != NULL)
+ append_entity(scope, entity);
if (token.type != ',') {
break;
!is_typedef_symbol(token.v.symbol)) {
token_type_t la1_type = (token_type_t)look_ahead(1)->type;
if (la1_type == ',' || la1_type == ')') {
- type->kr_style_parameters = true;
+ type->kr_style_parameters = true;
+ type->unspecified_parameters = true;
parse_identifier_list(scope);
goto parameters_finished;
}
parameters_finished:
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
restore_anchor_state(',', saved_comma_state);
}
rem_anchor_token(']');
- expect(']');
+ expect(']', end_error);
end_error:
return &array->construct_type;
case T__based:
next_token();
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
parse_microsoft_based(&base_spec);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
continue;
default:
env = NULL;
}
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
}
break;
default:
ndeclaration = parse_declarator(specifiers, flags);
rem_anchor_token('=');
}
- expect(';');
+ expect(';', end_error);
end_error:
anonymous_entity = NULL;
declaration_statement_t const *const decl = &stmt->declaration;
entity_t const * ent = decl->declarations_begin;
entity_t const *const last = decl->declarations_end;
- for (;; ent = ent->base.next) {
- if (ent->kind == ENTITY_VARIABLE &&
- ent->variable.initializer != NULL) {
- goto warn_unreachable;
+ if (ent != NULL) {
+ for (;; ent = ent->base.next) {
+ if (ent->kind == ENTITY_VARIABLE &&
+ ent->variable.initializer != NULL) {
+ goto warn_unreachable;
+ }
+ if (ent == last)
+ return;
}
- if (ent == last)
- return;
}
}
break;
next_token();
}
- expect(';');
+ expect(';', end_error);
end_error:
anonymous_entity = NULL;
type_t *type = parse_typename();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
if (token.type == '{') {
return parse_compound_literal(type);
expression->base.type = type;
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
return expression;
add_anchor_token(')');
expression_t *result = parse_expression();
+ result->base.parenthesized = true;
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
return result;
designator->source_position = *HERE;
designator->array_index = parse_expression();
rem_anchor_token(']');
- expect(']');
+ expect(']', end_error);
if (designator->array_index == NULL) {
return NULL;
}
eat(T___builtin_offsetof);
- expect('(');
+ expect('(', end_error);
add_anchor_token(',');
type_t *type = parse_typename();
rem_anchor_token(',');
- expect(',');
+ expect(',', end_error);
add_anchor_token(')');
designator_t *designator = parse_designator();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
expression->offsetofe.type = type;
expression->offsetofe.designator = designator;
eat(T___builtin_va_start);
- expect('(');
+ expect('(', end_error);
add_anchor_token(',');
expression->va_starte.ap = parse_assignment_expression();
rem_anchor_token(',');
- expect(',');
+ expect(',', end_error);
expression_t *const expr = parse_assignment_expression();
if (expr->kind == EXPR_REFERENCE) {
entity_t *const entity = expr->reference.entity;
} else {
expression->va_starte.parameter = &entity->variable;
}
- expect(')');
+ expect(')', end_error);
return expression;
}
- expect(')');
+ expect(')', end_error);
end_error:
return create_invalid_expression();
}
eat(T___builtin_va_arg);
- expect('(');
+ expect('(', end_error);
expression->va_arge.ap = parse_assignment_expression();
- expect(',');
+ expect(',', end_error);
expression->base.type = parse_typename();
- expect(')');
+ expect(')', end_error);
return expression;
end_error:
eat(T___builtin_constant_p);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression->builtin_constant.value = parse_assignment_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
expression->base.type = type_int;
return expression;
eat(T___builtin_prefetch);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression->builtin_prefetch.adr = parse_assignment_expression();
if (token.type == ',') {
expression->builtin_prefetch.locality = parse_assignment_expression();
}
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
expression->base.type = type_void;
return expression;
expression->base.source_position = *HERE;
next_token();
- expect('(');
+ expect('(', end_error);
expression->binary.left = parse_assignment_expression();
- expect(',');
+ expect(',', end_error);
expression->binary.right = parse_assignment_expression();
- expect(')');
+ expect(')', end_error);
type_t *const orig_type_left = expression->binary.left->base.type;
type_t *const orig_type_right = expression->binary.right->base.type;
#if 0
/**
- * Parses a __builtin_expect() expression.
+ * Parses a __builtin_expect(, end_error) expression.
*/
-static expression_t *parse_builtin_expect(void)
+static expression_t *parse_builtin_expect(void, end_error)
{
expression_t *expression
= allocate_expression_zero(EXPR_BINARY_BUILTIN_EXPECT);
eat(T___builtin_expect);
- expect('(');
+ expect('(', end_error);
expression->binary.left = parse_assignment_expression();
- expect(',');
+ expect(',', end_error);
expression->binary.right = parse_constant_expression();
- expect(')');
+ expect(')', end_error);
expression->base.type = expression->binary.left->base.type;
eat(T__assume);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression->unary.value = parse_assignment_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
expression->base.type = type_void;
return expression;
}
rem_anchor_token(',');
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
return cnst;
expression->base.type = automatic_type_conversion(return_type);
rem_anchor_token(']');
- expect(']');
+ expect(']', end_error);
end_error:
return expression;
}
add_anchor_token(')');
orig_type = parse_typename();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
if (token.type == '{') {
/* It was not sizeof(type) after all. It is sizeof of an expression
tp_expression->typeprop.type = orig_type;
type_t const* const type = skip_typeref(orig_type);
char const* const wrong_type =
- is_type_incomplete(type) ? "incomplete" :
- type->kind == TYPE_FUNCTION ? "function designator" :
- type->kind == TYPE_BITFIELD ? "bitfield" :
+ GNU_MODE && is_type_atomic(type, ATOMIC_TYPE_VOID) ? NULL :
+ is_type_incomplete(type) ? "incomplete" :
+ type->kind == TYPE_FUNCTION ? "function designator" :
+ type->kind == TYPE_BITFIELD ? "bitfield" :
NULL;
if (wrong_type != NULL) {
char const* const what = kind == EXPR_SIZEOF ? "sizeof" : "alignof";
}
rem_anchor_token(',');
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
if (function_type == NULL)
return result;
}
}
+static void warn_assignment_in_condition(const expression_t *const expr)
+{
+ if (!warning.parentheses)
+ return;
+ if (expr->base.kind != EXPR_BINARY_ASSIGN)
+ return;
+ if (expr->base.parenthesized)
+ return;
+ warningf(&expr->base.source_position,
+ "suggest parentheses around assignment used as truth value");
+}
+
static void semantic_condition(expression_t const *const expr,
char const *const context)
{
type_t *const type = skip_typeref(expr->base.type);
if (is_type_scalar(type)) {
warn_reference_address_as_bool(expr);
+ warn_assignment_in_condition(expr);
} else if (is_type_valid(type)) {
errorf(&expr->base.source_position,
"%s must have scalar type", context);
true_expression = parse_expression();
}
rem_anchor_token(':');
- expect(':');
+ expect(':', end_error);
+end_error:;
expression_t *false_expression =
parse_sub_expression(c_mode & _CXX ? PREC_ASSIGNMENT : PREC_CONDITIONAL);
= create_implicit_cast(false_expression, result_type);
conditional->base.type = result_type;
return result;
-end_error:
- return create_invalid_expression();
}
/**
eat(T___builtin_classify_type);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *expression = parse_expression();
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
result->classify_type.type_expression = expression;
return result;
if (token.type == '[') {
next_token();
result->kind = EXPR_UNARY_DELETE_ARRAY;
- expect(']');
+ expect(']', end_error);
end_error:;
}
{
/* TODO: doesn't seem to be consistent with §6.3.2.1 (1) */
switch (expression->kind) {
- case EXPR_REFERENCE:
case EXPR_ARRAY_ACCESS:
+ case EXPR_COMPOUND_LITERAL:
+ case EXPR_REFERENCE:
case EXPR_SELECT:
case EXPR_UNARY_DEREFERENCE:
return true;
}
}
+static void warn_comparison_in_comparison(const expression_t *const expr)
+{
+ if (expr->base.parenthesized)
+ return;
+ switch (expr->base.kind) {
+ case EXPR_BINARY_LESS:
+ case EXPR_BINARY_GREATER:
+ case EXPR_BINARY_LESSEQUAL:
+ case EXPR_BINARY_GREATEREQUAL:
+ case EXPR_BINARY_NOTEQUAL:
+ case EXPR_BINARY_EQUAL:
+ warningf(&expr->base.source_position,
+ "comparisons like 'x <= y < z' do not have their mathematical meaning");
+ break;
+ default:
+ break;
+ }
+}
+
/**
* Check the semantics of comparison expressions.
*
}
}
+ if (warning.parentheses) {
+ warn_comparison_in_comparison(left);
+ warn_comparison_in_comparison(right);
+ }
+
type_t *orig_type_left = left->base.type;
type_t *orig_type_right = right->base.type;
type_t *type_left = skip_typeref(orig_type_left);
}
}
+static void warn_logical_and_within_or(const expression_t *const expr)
+{
+ if (expr->base.kind != EXPR_BINARY_LOGICAL_AND)
+ return;
+ if (expr->base.parenthesized)
+ return;
+ warningf(&expr->base.source_position,
+ "suggest parentheses around && within ||");
+}
+
/**
* Check the semantic restrictions of a logical expression.
*/
* §6.5.14:2 Each of the operands shall have scalar type. */
semantic_condition(expression->left, "left operand of logical operator");
semantic_condition(expression->right, "right operand of logical operator");
+ if (expression->base.kind == EXPR_BINARY_LOGICAL_OR &&
+ warning.parentheses) {
+ warn_logical_and_within_or(expression->left);
+ warn_logical_and_within_or(expression->right);
+ }
expression->base.type = c_mode & _CXX ? type_bool : type_int;
}
}
argument->symbol = token.v.symbol;
- expect(']');
+ expect(']', end_error);
}
argument->constraints = parse_string_literals();
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *expression = parse_expression();
rem_anchor_token(')');
mark_vars_read(expression, NULL);
}
argument->expression = expression;
- expect(')');
+ expect(')', end_error);
set_address_taken(expression, true);
asm_statement->is_volatile = true;
}
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
add_anchor_token(':');
asm_statement->asm_text = parse_string_literals();
end_of_asm:
rem_anchor_token(')');
- expect(')');
- expect(';');
+ expect(')', end_error);
+ expect(';', end_error);
if (asm_statement->outputs == NULL) {
/* GCC: An 'asm' instruction without any output operands will be treated
PUSH_PARENT(statement);
- expect(':');
+ expect(':', end_error);
end_error:
if (current_switch != NULL) {
PUSH_PARENT(statement);
- expect(':');
+ expect(':', end_error);
if (current_switch != NULL) {
const case_label_statement_t *def_label = current_switch->default_label;
if (def_label != NULL) {
add_anchor_token('{');
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const expr = parse_expression();
statement->ifs.condition = expr;
semantic_condition(expr, "condition of 'if'-statment");
mark_vars_read(expr, NULL);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
end_error:
rem_anchor_token('{');
add_anchor_token(T_else);
- statement->ifs.true_statement = parse_statement();
+ statement_t *const true_stmt = parse_statement();
+ statement->ifs.true_statement = true_stmt;
rem_anchor_token(T_else);
if (token.type == T_else) {
next_token();
statement->ifs.false_statement = parse_statement();
+ } else if (warning.parentheses &&
+ true_stmt->kind == STATEMENT_IF &&
+ true_stmt->ifs.false_statement != NULL) {
+ warningf(&true_stmt->base.source_position,
+ "suggest explicit braces to avoid ambiguous 'else'");
}
POP_PARENT;
PUSH_PARENT(statement);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const expr = parse_expression();
mark_vars_read(expr, NULL);
type = type_error_type;
}
statement->switchs.expression = create_implicit_cast(expr, type);
- expect(')');
+ expect(')', end_error);
rem_anchor_token(')');
switch_statement_t *rem = current_switch;
PUSH_PARENT(statement);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const cond = parse_expression();
statement->whiles.condition = cond;
semantic_condition(cond, "condition of 'while'-statement");
mark_vars_read(cond, NULL);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
statement->whiles.body = parse_loop_body(statement);
statement->do_while.body = parse_loop_body(statement);
rem_anchor_token(T_while);
- expect(T_while);
- expect('(');
+ expect(T_while, end_error);
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const cond = parse_expression();
statement->do_while.condition = cond;
semantic_condition(cond, "condition of 'do-while'-statement");
mark_vars_read(cond, NULL);
rem_anchor_token(')');
- expect(')');
- expect(';');
+ expect(')', end_error);
+ expect(';', end_error);
POP_PARENT;
return statement;
eat(T_for);
+ expect('(', end_error1);
+ add_anchor_token(')');
+
PUSH_PARENT(statement);
size_t const top = environment_top();
scope_t *old_scope = scope_push(&statement->fors.scope);
- expect('(');
- add_anchor_token(')');
-
if (token.type == ';') {
next_token();
} else if (is_declaration_specifier(&token, false)) {
"initialisation of 'for'-statement has no effect");
}
rem_anchor_token(';');
- expect(';');
+ expect(';', end_error2);
}
if (token.type != ';') {
mark_vars_read(cond, NULL);
rem_anchor_token(';');
}
- expect(';');
+ expect(';', end_error2);
if (token.type != ')') {
expression_t *const step = parse_expression();
statement->fors.step = step;
"step of 'for'-statement has no effect");
}
}
- expect(')');
+ expect(')', end_error2);
rem_anchor_token(')');
statement->fors.body = parse_loop_body(statement);
POP_PARENT;
return statement;
-end_error:
+end_error2:
POP_PARENT;
rem_anchor_token(')');
assert(current_scope == &statement->fors.scope);
scope_pop(old_scope);
environment_pop_to(top);
+ /* fallthrough */
+end_error1:
return create_invalid_statement();
}
*goto_anchor = &statement->gotos;
goto_anchor = &statement->gotos.next;
- expect(';');
+ expect(';', end_error);
return statement;
end_error:
statement_t *statement = allocate_statement_zero(STATEMENT_CONTINUE);
eat(T_continue);
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
statement_t *statement = allocate_statement_zero(STATEMENT_BREAK);
eat(T_break);
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
statement_t *statement = allocate_statement_zero(STATEMENT_LEAVE);
eat(T___leave);
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
assert(is_type_function(func_type));
type_t *const return_type = skip_typeref(func_type->function.return_type);
+ source_position_t const *const pos = &statement->base.source_position;
if (return_value != NULL) {
type_t *return_value_type = skip_typeref(return_value->base.type);
- if (is_type_atomic(return_type, ATOMIC_TYPE_VOID) &&
- !is_type_atomic(return_value_type, ATOMIC_TYPE_VOID)) {
- if (warning.other) {
- warningf(&statement->base.source_position,
- "'return' with a value, in function returning void");
+ if (is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
+ if (is_type_atomic(return_value_type, ATOMIC_TYPE_VOID)) {
+ /* ISO/IEC 14882:1998(E) §6.6.3:2 */
+ /* Only warn in C mode, because GCC does the same */
+ if (c_mode & _CXX || strict_mode) {
+ errorf(pos,
+ "'return' with a value, in function returning 'void'");
+ } else if (warning.other) {
+ warningf(pos,
+ "'return' with a value, in function returning 'void'");
+ }
+ } else if (!(c_mode & _CXX)) { /* ISO/IEC 14882:1998(E) §6.6.3:3 */
+ /* Only warn in C mode, because GCC does the same */
+ if (strict_mode) {
+ errorf(pos,
+ "'return' with expression in function return 'void'");
+ } else if (warning.other) {
+ warningf(pos,
+ "'return' with expression in function return 'void'");
+ }
}
- return_value = NULL;
} else {
assign_error_t error = semantic_assign(return_type, return_value);
report_assign_error(error, return_type, return_value, "'return'",
- &statement->base.source_position);
- return_value = create_implicit_cast(return_value, return_type);
+ pos);
}
+ return_value = create_implicit_cast(return_value, return_type);
/* check for returning address of a local var */
if (warning.other && return_value != NULL
&& return_value->base.kind == EXPR_UNARY_TAKE_ADDRESS) {
const expression_t *expression = return_value->unary.value;
if (expression_is_local_variable(expression)) {
- warningf(&statement->base.source_position,
- "function returns address of local variable");
+ warningf(pos, "function returns address of local variable");
}
}
} else if (warning.other && !is_type_atomic(return_type, ATOMIC_TYPE_VOID)) {
- warningf(&statement->base.source_position,
- "'return' without value, in function returning non-void");
+ /* ISO/IEC 14882:1998(E) §6.6.3:3 */
+ if (c_mode & _CXX || strict_mode) {
+ errorf(pos,
+ "'return' without value, in function returning non-void");
+ } else {
+ warningf(pos,
+ "'return' without value, in function returning non-void");
+ }
}
statement->returns.value = return_value;
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
statement->expression.expression = expr;
mark_vars_read(expr, ENT_ANY);
- expect(';');
+ expect(';', end_error);
end_error:
return statement;
if (token.type == T___except) {
eat(T___except);
- expect('(');
+ expect('(', end_error);
add_anchor_token(')');
expression_t *const expr = parse_expression();
mark_vars_read(expr, NULL);
}
statement->ms_try.except_expression = create_implicit_cast(expr, type);
rem_anchor_token(')');
- expect(')');
+ expect(')', end_error);
statement->ms_try.final_statement = parse_compound_statement(false);
} else if (token.type == T__finally) {
eat(T___finally);
size_t const top = environment_top();
scope_t *old_scope = scope_push(&entity->namespacee.members);
- expect('{');
+ expect('{', end_error);
parse_externals();
- expect('}');
+ expect('}', end_error);
end_error:
assert(current_scope == &entity->namespacee.members);
statement_t *statement = allocate_statement_zero(STATEMENT_ASM);
eat(T_asm);
- expect('(');
+ expect('(', end_error);
statement->asms.asm_text = parse_string_literals();
statement->base.next = unit->global_asm;
unit->global_asm = statement;
- expect(')');
- expect(';');
+ expect(')', end_error);
+ expect(';', end_error);
end_error:;
}
if (token.type == '{') {
next_token();
parse_externals();
- expect('}');
+ expect('}', end_error);
} else {
parse_external();
}
projects / cparser / blobdiff