#include "type_hash.h"
#include "ast_t.h"
#include "lang_features.h"
+#include "warning.h"
#include "adt/bitfiddle.h"
#include "adt/error.h"
#include "adt/array.h"
//#define PRINT_TOKENS
-//#define ABORT_ON_ERROR
#define MAX_LOOKAHEAD 2
typedef struct {
static int lookahead_bufpos;
static stack_entry_t *environment_stack = NULL;
static stack_entry_t *label_stack = NULL;
-static context_t *global_context = NULL;
-static context_t *context = NULL;
+static scope_t *global_scope = NULL;
+static scope_t *scope = NULL;
static declaration_t *last_declaration = NULL;
static declaration_t *current_function = NULL;
static switch_statement_t *current_switch = NULL;
static statement_t *current_loop = NULL;
static goto_statement_t *goto_first = NULL;
static goto_statement_t *goto_last = NULL;
+static label_statement_t *label_first = NULL;
+static label_statement_t *label_last = NULL;
static struct obstack temp_obst;
/** The current source position. */
static declaration_t *allocate_declaration_zero(void)
{
- return allocate_ast_zero(sizeof(*allocate_declaration_zero()));
+ declaration_t *declaration = allocate_ast_zero(sizeof(*allocate_declaration_zero()));
+ declaration->type = type_error_type;
+ return declaration;
}
/**
size_t size = get_expression_struct_size(kind);
expression_t *res = allocate_ast_zero(size);
- res->base.kind = kind;
+ res->base.kind = kind;
+ res->base.datatype = type_error_type;
return res;
}
} \
next_token();
-static void set_context(context_t *new_context)
+static void set_scope(scope_t *new_scope)
{
- context = new_context;
+ scope = new_scope;
- last_declaration = new_context->declarations;
+ last_declaration = new_scope->declarations;
if(last_declaration != NULL) {
while(last_declaration->next != NULL) {
last_declaration = last_declaration->next;
static void environment_push(declaration_t *declaration)
{
assert(declaration->source_position.input_name != NULL);
- assert(declaration->parent_context != NULL);
+ assert(declaration->parent_scope != NULL);
stack_push(&environment_stack, declaration);
}
static void label_push(declaration_t *declaration)
{
- declaration->parent_context = ¤t_function->context;
+ declaration->parent_scope = ¤t_function->scope;
stack_push(&label_stack, declaration);
}
return ATOMIC_TYPE_INT;
assert(type->kind == TYPE_ATOMIC);
- const atomic_type_t *atomic_type = &type->atomic;
- atomic_type_kind_t atype = atomic_type->akind;
- return atype;
+ return type->atomic.akind;
}
static type_t *promote_integer(type_t *type)
{
if(type->kind == TYPE_BITFIELD)
- return promote_integer(type->bitfield.base);
+ type = type->bitfield.base;
if(get_rank(type) < ATOMIC_TYPE_INT)
type = type_int;
static expression_t *create_implicit_cast(expression_t *expression,
type_t *dest_type)
{
- type_t *source_type = expression->base.datatype;
-
- if(source_type == NULL)
- return expression;
-
- source_type = skip_typeref(source_type);
- dest_type = skip_typeref(dest_type);
+ type_t *const source_type = expression->base.datatype;
- if(source_type == dest_type)
+ if (source_type == dest_type)
return expression;
- switch (dest_type->kind) {
- case TYPE_ENUM:
- /* TODO warning for implicitly converting to enum */
- case TYPE_BITFIELD:
- case TYPE_ATOMIC:
- if (source_type->kind != TYPE_ATOMIC &&
- source_type->kind != TYPE_ENUM &&
- source_type->kind != TYPE_BITFIELD) {
- panic("casting of non-atomic types not implemented yet");
- }
-
- if(is_type_floating(dest_type) && !is_type_scalar(source_type)) {
- type_error_incompatible("can't cast types",
- expression->base.source_position, source_type,
- dest_type);
- return expression;
- }
-
- return create_cast_expression(expression, dest_type);
-
- case TYPE_POINTER:
- switch (source_type->kind) {
- case TYPE_ATOMIC:
- if (is_null_pointer_constant(expression)) {
- return create_cast_expression(expression, dest_type);
- }
- break;
-
- case TYPE_POINTER:
- if (pointers_compatible(source_type, dest_type)) {
- return create_cast_expression(expression, dest_type);
- }
- break;
-
- case TYPE_ARRAY: {
- array_type_t *array_type = &source_type->array;
- pointer_type_t *pointer_type = &dest_type->pointer;
- if (types_compatible(array_type->element_type,
- pointer_type->points_to)) {
- return create_cast_expression(expression, dest_type);
- }
- break;
- }
-
- default:
- panic("casting of non-atomic types not implemented yet");
- }
-
- type_error_incompatible("can't implicitly cast types",
- expression->base.source_position, source_type, dest_type);
- return expression;
-
- default:
- panic("casting of non-atomic types not implemented yet");
- }
+ return create_cast_expression(expression, dest_type);
}
/** Implements the rules from ยง 6.5.16.1 */
-static void semantic_assign(type_t *orig_type_left, expression_t **right,
+static type_t *semantic_assign(type_t *orig_type_left,
+ const expression_t *const right,
const char *context)
{
- type_t *orig_type_right = (*right)->base.datatype;
-
- if(orig_type_right == NULL)
- return;
-
- type_t *const type_left = skip_typeref(orig_type_left);
- type_t *const type_right = skip_typeref(orig_type_right);
+ type_t *const orig_type_right = right->base.datatype;
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
if ((is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) ||
- (is_type_pointer(type_left) && is_null_pointer_constant(*right)) ||
+ (is_type_pointer(type_left) && is_null_pointer_constant(right)) ||
(is_type_atomic(type_left, ATOMIC_TYPE_BOOL)
&& is_type_pointer(type_right))) {
- *right = create_implicit_cast(*right, type_left);
- return;
+ return orig_type_left;
}
if (is_type_pointer(type_left) && is_type_pointer(type_right)) {
- pointer_type_t *pointer_type_left = &type_left->pointer;
- pointer_type_t *pointer_type_right = &type_right->pointer;
- type_t *points_to_left = pointer_type_left->points_to;
- type_t *points_to_right = pointer_type_right->points_to;
-
- points_to_left = skip_typeref(points_to_left);
- points_to_right = skip_typeref(points_to_right);
+ type_t *points_to_left = skip_typeref(type_left->pointer.points_to);
+ type_t *points_to_right = skip_typeref(type_right->pointer.points_to);
/* the left type has all qualifiers from the right type */
unsigned missing_qualifiers
= points_to_right->base.qualifiers & ~points_to_left->base.qualifiers;
if(missing_qualifiers != 0) {
errorf(HERE, "destination type '%T' in %s from type '%T' lacks qualifiers '%Q' in pointed-to type", type_left, context, type_right, missing_qualifiers);
- return;
+ return orig_type_left;
}
points_to_left = get_unqualified_type(points_to_left);
if(!is_type_atomic(points_to_left, ATOMIC_TYPE_VOID)
&& !is_type_atomic(points_to_right, ATOMIC_TYPE_VOID)
&& !types_compatible(points_to_left, points_to_right)) {
- goto incompatible_assign_types;
+ return NULL;
}
- *right = create_implicit_cast(*right, type_left);
- return;
+ return orig_type_left;
}
- if (is_type_compound(type_left)
- && types_compatible(type_left, type_right)) {
- *right = create_implicit_cast(*right, type_left);
- return;
+ if (is_type_compound(type_left) && is_type_compound(type_right)) {
+ type_t *const unqual_type_left = get_unqualified_type(type_left);
+ type_t *const unqual_type_right = get_unqualified_type(type_right);
+ if (types_compatible(unqual_type_left, unqual_type_right)) {
+ return orig_type_left;
+ }
}
-incompatible_assign_types:
- /* TODO: improve error message */
- errorf(HERE, "incompatible types in %s: '%T' <- '%T'",
- context, orig_type_left, orig_type_right);
+ if (!is_type_valid(type_left))
+ return type_left;
+
+ if (!is_type_valid(type_right))
+ return orig_type_right;
+
+ return NULL;
}
static expression_t *parse_constant_expression(void)
return typedef_type;
}
-static const char *parse_string_literals(void)
+static string_t parse_string_literals(void)
{
assert(token.type == T_STRING_LITERAL);
- const char *result = token.v.string;
+ string_t result = token.v.string;
next_token();
- while(token.type == T_STRING_LITERAL) {
- result = concat_strings(result, token.v.string);
+ while (token.type == T_STRING_LITERAL) {
+ result = concat_strings(&result, &token.v.string);
next_token();
}
#endif
static initializer_t *initializer_from_string(array_type_t *type,
- const char *string)
+ const string_t *const string)
{
/* TODO: check len vs. size of array type */
(void) type;
initializer_t *initializer = allocate_initializer_zero(INITIALIZER_STRING);
- initializer->string.string = string;
+ initializer->string.string = *string;
return initializer;
}
case EXPR_STRING_LITERAL:
if (element_type->atomic.akind == ATOMIC_TYPE_CHAR) {
return initializer_from_string(array_type,
- expression->string.value);
+ &expression->string.value);
}
case EXPR_WIDE_STRING_LITERAL: {
}
}
- type_t *expression_type = skip_typeref(expression->base.datatype);
- if(is_type_scalar(type) || types_compatible(type, expression_type)) {
- semantic_assign(type, &expression, "initializer");
-
- initializer_t *result = allocate_initializer_zero(INITIALIZER_VALUE);
- result->value.value = expression;
+ type_t *const res_type = semantic_assign(type, expression, "initializer");
+ if (res_type == NULL)
+ return NULL;
- return result;
- }
+ initializer_t *const result = allocate_initializer_zero(INITIALIZER_VALUE);
+ result->value.value = create_implicit_cast(expression, res_type);
- return NULL;
+ return result;
}
static initializer_t *parse_sub_initializer(type_t *type,
- expression_t *expression,
- type_t *expression_type);
+ expression_t *expression);
static initializer_t *parse_sub_initializer_elem(type_t *type)
{
if(token.type == '{') {
- return parse_sub_initializer(type, NULL, NULL);
+ return parse_sub_initializer(type, NULL);
}
- expression_t *expression = parse_assignment_expression();
- type_t *expression_type = skip_typeref(expression->base.datatype);
-
- return parse_sub_initializer(type, expression, expression_type);
+ expression_t *expression = parse_assignment_expression();
+ return parse_sub_initializer(type, expression);
}
static bool had_initializer_brace_warning;
}
static initializer_t *parse_sub_initializer(type_t *type,
- expression_t *expression,
- type_t *expression_type)
+ expression_t *expression)
{
if(is_type_scalar(type)) {
/* there might be extra {} hierarchies */
warningf(HERE, "braces around scalar initializer");
had_initializer_brace_warning = true;
}
- initializer_t *result = parse_sub_initializer(type, NULL, NULL);
+ initializer_t *result = parse_sub_initializer(type, NULL);
if(token.type == ',') {
next_token();
/* TODO: warn about excessive elements */
initializer_t *result = NULL;
initializer_t **elems;
if(is_type_array(type)) {
- array_type_t *array_type = &type->array;
- type_t *element_type = array_type->element_type;
- element_type = skip_typeref(element_type);
-
if(token.type == '.') {
errorf(HERE,
"compound designator in initializer for array type '%T'",
skip_designator();
}
+ type_t *const element_type = skip_typeref(type->array.element_type);
+
initializer_t *sub;
had_initializer_brace_warning = false;
if(expression == NULL) {
sub = parse_sub_initializer_elem(element_type);
} else {
- sub = parse_sub_initializer(element_type, expression,
- expression_type);
+ sub = parse_sub_initializer(element_type, expression);
}
/* didn't match the subtypes -> try the parent type */
}
} else {
assert(is_type_compound(type));
- compound_type_t *compound_type = &type->compound;
- context_t *context = &compound_type->declaration->context;
+ scope_t *const scope = &type->compound.declaration->scope;
if(token.type == '[') {
errorf(HERE,
skip_designator();
}
- declaration_t *first = context->declarations;
+ declaration_t *first = scope->declarations;
if(first == NULL)
return NULL;
type_t *first_type = first->type;
if(expression == NULL) {
sub = parse_sub_initializer_elem(first_type);
} else {
- sub = parse_sub_initializer(first_type, expression,expression_type);
+ sub = parse_sub_initializer(first_type, expression);
}
/* didn't match the subtypes -> try our parent type */
return result;
}
-static initializer_t *parse_initializer(type_t *type)
+static initializer_t *parse_initializer(type_t *const orig_type)
{
initializer_t *result;
- type = skip_typeref(type);
+ type_t *const type = skip_typeref(orig_type);
if(token.type != '{') {
expression_t *expression = parse_assignment_expression();
if(initializer == NULL) {
errorf(HERE,
"initializer expression '%E' of type '%T' is incompatible with type '%T'",
- expression, expression->base.datatype, type);
+ expression, expression->base.datatype, orig_type);
}
return initializer;
}
expect('}');
return result;
} else {
- result = parse_sub_initializer(type, NULL, NULL);
+ result = parse_sub_initializer(type, NULL);
}
return result;
(is_struct ? NAMESPACE_STRUCT : NAMESPACE_UNION);
declaration->source_position = token.source_position;
declaration->symbol = symbol;
- declaration->parent_context = context;
+ declaration->parent_scope = scope;
if (symbol != NULL) {
environment_push(declaration);
}
assert(symbol != NULL);
errorf(HERE, "multiple definition of '%s %Y'",
is_struct ? "struct" : "union", symbol);
- declaration->context.declarations = NULL;
+ declaration->scope.declarations = NULL;
}
declaration->init.is_defined = true;
- int top = environment_top();
- context_t *last_context = context;
- set_context(&declaration->context);
+ int top = environment_top();
+ scope_t *last_scope = scope;
+ set_scope(&declaration->scope);
parse_compound_type_entries();
parse_attributes();
- assert(context == &declaration->context);
- set_context(last_context);
+ assert(scope == &declaration->scope);
+ set_scope(last_scope);
environment_pop_to(top);
}
declaration->namespc = NAMESPACE_ENUM;
declaration->source_position = token.source_position;
declaration->symbol = symbol;
- declaration->parent_context = context;
+ declaration->parent_scope = scope;
}
type_t *const type = allocate_type_zero(TYPE_ENUM);
}
break;
- /* TODO: if type != NULL for the following rules should issue
+ /* TODO: if is_type_valid(type) for the following rules should issue
* an error */
case T_struct: {
type = allocate_type_zero(TYPE_COMPOUND_STRUCT);
/* invalid specifier combination, give an error message */
if(type_specifiers == 0) {
if (! strict_mode) {
- warningf(HERE, "no type specifiers in declaration, using int");
+ if (warning.implicit_int) {
+ warningf(HERE, "no type specifiers in declaration, using 'int'");
+ }
atomic_type = ATOMIC_TYPE_INT;
break;
} else {
errorf(HERE, "parameter may only have none or register storage class");
}
- type_t *orig_type = declaration->type;
- if(orig_type == NULL)
- return;
- type_t *type = skip_typeref(orig_type);
+ type_t *const orig_type = declaration->type;
+ type_t * type = skip_typeref(orig_type);
/* Array as last part of a parameter type is just syntactic sugar. Turn it
* into a pointer. ยง 6.7.5.3 (7) */
if (is_type_array(type)) {
- const array_type_t *arr_type = &type->array;
- type_t *element_type = arr_type->element_type;
+ type_t *const element_type = type->array.element_type;
type = make_pointer_type(element_type, type->base.qualifiers);
declaration_t *parameters = parse_parameters(&type->function);
if(declaration != NULL) {
- declaration->context.declarations = parameters;
+ declaration->scope.declarations = parameters;
}
construct_function_type_t *construct_function_type =
function_type->function.return_type = type;
- type = function_type;
+ type_t *skipped_return_type = skip_typeref(type);
+ if (is_type_function(skipped_return_type)) {
+ errorf(HERE, "function returning function is not allowed");
+ type = type_error_type;
+ } else if (is_type_array(skipped_return_type)) {
+ errorf(HERE, "function returning array is not allowed");
+ type = type_error_type;
+ } else {
+ type = function_type;
+ }
break;
}
array_type->array.is_variable = parsed_array->is_variable;
array_type->array.size = parsed_array->size;
- type = array_type;
+ type_t *skipped_type = skip_typeref(type);
+ if (is_type_atomic(skipped_type, ATOMIC_TYPE_VOID)) {
+ errorf(HERE, "array of void is not allowed");
+ type = type_error_type;
+ } else {
+ type = array_type;
+ }
break;
}
}
static declaration_t *parse_declarator(
const declaration_specifiers_t *specifiers, bool may_be_abstract)
{
- type_t *type = specifiers->type;
declaration_t *const declaration = allocate_declaration_zero();
declaration->storage_class = specifiers->storage_class;
declaration->modifiers = specifiers->decl_modifiers;
construct_type_t *construct_type
= parse_inner_declarator(declaration, may_be_abstract);
+ type_t *const type = specifiers->type;
declaration->type = construct_declarator_type(construct_type, type);
if(construct_type != NULL) {
if (last_declaration != NULL) {
last_declaration->next = declaration;
} else {
- context->declarations = declaration;
+ scope->declarations = declaration;
}
last_declaration = declaration;
return declaration;
}
+/**
+ * Check if the declaration of main is suspicious. main should be a
+ * function with external linkage, returning int, taking either zero
+ * arguments, two, or three arguments of appropriate types, ie.
+ *
+ * int main([ int argc, char **argv [, char **env ] ]).
+ *
+ * @param decl the declaration to check
+ * @param type the function type of the declaration
+ */
+static void check_type_of_main(const declaration_t *const decl, const function_type_t *const func_type)
+{
+ if (decl->storage_class == STORAGE_CLASS_STATIC) {
+ warningf(decl->source_position, "'main' is normally a non-static function");
+ }
+ if (skip_typeref(func_type->return_type) != type_int) {
+ warningf(decl->source_position, "return type of 'main' should be 'int', but is '%T'", func_type->return_type);
+ }
+ const function_parameter_t *parm = func_type->parameters;
+ if (parm != NULL) {
+ type_t *const first_type = parm->type;
+ if (!types_compatible(skip_typeref(first_type), type_int)) {
+ warningf(decl->source_position, "first argument of 'main' should be 'int', but is '%T'", first_type);
+ }
+ parm = parm->next;
+ if (parm != NULL) {
+ type_t *const second_type = parm->type;
+ if (!types_compatible(skip_typeref(second_type), type_char_ptr_ptr)) {
+ warningf(decl->source_position, "second argument of 'main' should be 'char**', but is '%T'", second_type);
+ }
+ parm = parm->next;
+ if (parm != NULL) {
+ type_t *const third_type = parm->type;
+ if (!types_compatible(skip_typeref(third_type), type_char_ptr_ptr)) {
+ warningf(decl->source_position, "third argument of 'main' should be 'char**', but is '%T'", third_type);
+ }
+ parm = parm->next;
+ if (parm != NULL) {
+ warningf(decl->source_position, "'main' takes only zero, two or three arguments");
+ }
+ }
+ } else {
+ warningf(decl->source_position, "'main' takes only zero, two or three arguments");
+ }
+ }
+}
+
+/**
+ * Check if a symbol is the equal to "main".
+ */
+static bool is_sym_main(const symbol_t *const sym)
+{
+ return strcmp(sym->string, "main") == 0;
+}
+
static declaration_t *internal_record_declaration(
declaration_t *const declaration,
const bool is_function_definition)
const symbol_t *const symbol = declaration->symbol;
const namespace_t namespc = (namespace_t)declaration->namespc;
- const type_t *const type = skip_typeref(declaration->type);
- if (is_type_function(type) && type->function.unspecified_parameters) {
+ type_t *const orig_type = declaration->type;
+ const type_t *const type = skip_typeref(orig_type);
+ if (is_type_function(type) &&
+ type->function.unspecified_parameters &&
+ warning.strict_prototypes) {
warningf(declaration->source_position,
"function declaration '%#T' is not a prototype",
- type, declaration->symbol);
+ orig_type, declaration->symbol);
+ }
+
+ if (is_function_definition && warning.main && is_sym_main(symbol)) {
+ check_type_of_main(declaration, &type->function);
}
declaration_t *const previous_declaration = get_declaration(symbol, namespc);
assert(declaration != previous_declaration);
- if (previous_declaration != NULL
- && previous_declaration->parent_context == context) {
- /* can happen for K&R style declarations */
- if(previous_declaration->type == NULL) {
- previous_declaration->type = declaration->type;
- }
-
- const type_t *const prev_type = skip_typeref(previous_declaration->type);
- if (!types_compatible(type, prev_type)) {
- errorf(declaration->source_position,
- "declaration '%#T' is incompatible with previous declaration '%#T'",
- type, symbol, previous_declaration->type, symbol);
- errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
- } else {
- unsigned old_storage_class = previous_declaration->storage_class;
- unsigned new_storage_class = declaration->storage_class;
-
- /* pretend no storage class means extern for function declarations
- * (except if the previous declaration is neither none nor extern) */
- if (is_type_function(type)) {
- switch (old_storage_class) {
- case STORAGE_CLASS_NONE:
- old_storage_class = STORAGE_CLASS_EXTERN;
-
- case STORAGE_CLASS_EXTERN:
- if (new_storage_class == STORAGE_CLASS_NONE && !is_function_definition) {
- new_storage_class = STORAGE_CLASS_EXTERN;
- }
- break;
+ if (previous_declaration != NULL) {
+ if (previous_declaration->parent_scope == scope) {
+ /* can happen for K&R style declarations */
+ if(previous_declaration->type == NULL) {
+ previous_declaration->type = declaration->type;
+ }
- default: break;
+ const type_t *const prev_type = skip_typeref(previous_declaration->type);
+ if (!types_compatible(type, prev_type)) {
+ errorf(declaration->source_position,
+ "declaration '%#T' is incompatible with previous declaration '%#T'",
+ orig_type, symbol, previous_declaration->type, symbol);
+ errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
+ } else {
+ unsigned old_storage_class = previous_declaration->storage_class;
+ unsigned new_storage_class = declaration->storage_class;
+
+ /* pretend no storage class means extern for function declarations
+ * (except if the previous declaration is neither none nor extern) */
+ if (is_type_function(type)) {
+ switch (old_storage_class) {
+ case STORAGE_CLASS_NONE:
+ old_storage_class = STORAGE_CLASS_EXTERN;
+
+ case STORAGE_CLASS_EXTERN:
+ if (is_function_definition) {
+ if (warning.missing_prototypes &&
+ prev_type->function.unspecified_parameters &&
+ !is_sym_main(symbol)) {
+ warningf(declaration->source_position, "no previous prototype for '%#T'", orig_type, symbol);
+ }
+ } else if (new_storage_class == STORAGE_CLASS_NONE) {
+ new_storage_class = STORAGE_CLASS_EXTERN;
+ }
+ break;
+
+ default: break;
+ }
}
- }
- if (old_storage_class == STORAGE_CLASS_EXTERN &&
- new_storage_class == STORAGE_CLASS_EXTERN) {
+ if (old_storage_class == STORAGE_CLASS_EXTERN &&
+ new_storage_class == STORAGE_CLASS_EXTERN) {
warn_redundant_declaration:
- warningf(declaration->source_position, "redundant declaration for '%Y'", symbol);
- warningf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
- } else if (current_function == NULL) {
- if (old_storage_class != STORAGE_CLASS_STATIC &&
- new_storage_class == STORAGE_CLASS_STATIC) {
- errorf(declaration->source_position, "static declaration of '%Y' follows non-static declaration", symbol);
- errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
- } else {
- if (old_storage_class != STORAGE_CLASS_EXTERN) {
- goto warn_redundant_declaration;
+ if (warning.redundant_decls) {
+ warningf(declaration->source_position, "redundant declaration for '%Y'", symbol);
+ warningf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
}
- if (new_storage_class == STORAGE_CLASS_NONE) {
- previous_declaration->storage_class = STORAGE_CLASS_NONE;
+ } else if (current_function == NULL) {
+ if (old_storage_class != STORAGE_CLASS_STATIC &&
+ new_storage_class == STORAGE_CLASS_STATIC) {
+ errorf(declaration->source_position, "static declaration of '%Y' follows non-static declaration", symbol);
+ errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
+ } else {
+ if (old_storage_class != STORAGE_CLASS_EXTERN && !is_function_definition) {
+ goto warn_redundant_declaration;
+ }
+ if (new_storage_class == STORAGE_CLASS_NONE) {
+ previous_declaration->storage_class = STORAGE_CLASS_NONE;
+ }
}
- }
- } else {
- if (old_storage_class == new_storage_class) {
- errorf(declaration->source_position, "redeclaration of '%Y'", symbol);
} else {
- errorf(declaration->source_position, "redeclaration of '%Y' with different linkage", symbol);
+ if (old_storage_class == new_storage_class) {
+ errorf(declaration->source_position, "redeclaration of '%Y'", symbol);
+ } else {
+ errorf(declaration->source_position, "redeclaration of '%Y' with different linkage", symbol);
+ }
+ errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
}
- errorf(previous_declaration->source_position, "previous declaration of '%Y' was here", symbol);
}
+ return previous_declaration;
}
- return previous_declaration;
+ } else if (is_function_definition) {
+ if (declaration->storage_class != STORAGE_CLASS_STATIC) {
+ if (warning.missing_prototypes && !is_sym_main(symbol)) {
+ warningf(declaration->source_position, "no previous prototype for '%#T'", orig_type, symbol);
+ } else if (warning.missing_declarations && !is_sym_main(symbol)) {
+ warningf(declaration->source_position, "no previous declaration for '%#T'", orig_type, symbol);
+ }
+ }
+ } else if (warning.missing_declarations &&
+ scope == global_scope &&
+ !is_type_function(type) && (
+ declaration->storage_class == STORAGE_CLASS_NONE ||
+ declaration->storage_class == STORAGE_CLASS_THREAD
+ )) {
+ warningf(declaration->source_position, "no previous declaration for '%#T'", orig_type, symbol);
}
- assert(declaration->parent_context == NULL);
+ assert(declaration->parent_scope == NULL);
assert(declaration->symbol != NULL);
- assert(context != NULL);
+ assert(scope != NULL);
- declaration->parent_context = context;
+ declaration->parent_scope = scope;
environment_push(declaration);
return append_declaration(declaration);
return internal_record_declaration(declaration, false);
}
-static declaration_t *record_function_definition(declaration_t *const declaration)
+static declaration_t *record_function_definition(declaration_t *declaration)
{
return internal_record_declaration(declaration, true);
}
eat('=');
type_t *orig_type = declaration->type;
- type_t *type = NULL;
- if(orig_type != NULL)
- type = skip_typeref(orig_type);
+ type_t *type = type = skip_typeref(orig_type);
if(declaration->init.initializer != NULL) {
parser_error_multiple_definition(declaration, token.source_position);
/* ยง 6.7.5 (22) array initializers for arrays with unknown size determine
* the array type size */
- if(type != NULL && is_type_array(type) && initializer != NULL) {
+ if(is_type_array(type) && initializer != NULL) {
array_type_t *array_type = &type->array;
if(array_type->size == NULL) {
switch (initializer->kind) {
case INITIALIZER_LIST: {
- initializer_list_t *const list = &initializer->list;
- cnst->conste.v.int_value = list->len;
+ cnst->conste.v.int_value = initializer->list.len;
break;
}
case INITIALIZER_STRING: {
- initializer_string_t *const string = &initializer->string;
- cnst->conste.v.int_value = strlen(string->string) + 1;
+ cnst->conste.v.int_value = initializer->string.string.size;
break;
}
case INITIALIZER_WIDE_STRING: {
- initializer_wide_string_t *const string = &initializer->wide_string;
- cnst->conste.v.int_value = string->string.size;
+ cnst->conste.v.int_value = initializer->wide_string.string.size;
break;
}
}
}
- if(type != NULL && is_type_function(type)) {
+ if(is_type_function(type)) {
errorf(declaration->source_position,
"initializers not allowed for function types at declator '%Y' (type '%T')",
declaration->symbol, orig_type);
switch (type->kind) {
case TYPE_COMPOUND_STRUCT:
case TYPE_COMPOUND_UNION: {
- const compound_type_t *compound_type = &type->compound;
- if (compound_type->declaration->symbol == NULL) {
+ if (type->compound.declaration->symbol == NULL) {
warningf(declaration->source_position, "unnamed struct/union that defines no instances");
}
break;
type_t *orig_type = declaration->type;
type_t *type = skip_typeref(orig_type);
- if(type->kind != TYPE_FUNCTION && declaration->is_inline) {
+ if (type->kind != TYPE_FUNCTION &&
+ declaration->is_inline &&
+ is_type_valid(type)) {
warningf(declaration->source_position,
"variable '%Y' declared 'inline'\n", declaration->symbol);
}
declaration_t *previous_declaration = get_declaration(symbol, namespc);
if(previous_declaration == NULL ||
- previous_declaration->parent_context != context) {
+ previous_declaration->parent_scope != scope) {
errorf(HERE, "expected declaration of a function parameter, found '%Y'",
symbol);
return declaration;
if(previous_declaration->type == NULL) {
previous_declaration->type = declaration->type;
previous_declaration->storage_class = declaration->storage_class;
- previous_declaration->parent_context = context;
+ previous_declaration->parent_scope = scope;
return previous_declaration;
} else {
return record_declaration(declaration);
return;
/* push function parameters */
- int top = environment_top();
- context_t *last_context = context;
- set_context(&declaration->context);
+ int top = environment_top();
+ scope_t *last_scope = scope;
+ set_scope(&declaration->scope);
- declaration_t *parameter = declaration->context.declarations;
+ declaration_t *parameter = declaration->scope.declarations;
for( ; parameter != NULL; parameter = parameter->next) {
- assert(parameter->parent_context == NULL);
- parameter->parent_context = context;
+ assert(parameter->parent_scope == NULL);
+ parameter->parent_scope = scope;
environment_push(parameter);
}
}
/* pop function parameters */
- assert(context == &declaration->context);
- set_context(last_context);
+ assert(scope == &declaration->scope);
+ set_scope(last_scope);
environment_pop_to(top);
/* update function type */
function_parameter_t *parameters = NULL;
function_parameter_t *last_parameter = NULL;
- declaration_t *parameter_declaration = declaration->context.declarations;
+ declaration_t *parameter_declaration = declaration->scope.declarations;
for( ; parameter_declaration != NULL;
parameter_declaration = parameter_declaration->next) {
type_t *parameter_type = parameter_declaration->type;
errorf(HERE, "no type specified for function parameter '%Y'",
parameter_declaration->symbol);
} else {
- warningf(HERE, "no type specified for function parameter '%Y', using int",
- parameter_declaration->symbol);
+ if (warning.implicit_int) {
+ warningf(HERE, "no type specified for function parameter '%Y', using 'int'",
+ parameter_declaration->symbol);
+ }
parameter_type = type_int;
parameter_declaration->type = parameter_type;
}
/**
* Check if all labels are defined in the current function.
+ * Check if all labels are used in the current function.
*/
-static void check_for_missing_labels(void)
+static void check_labels(void)
{
bool first_err = true;
for (const goto_statement_t *goto_statement = goto_first;
- goto_statement != NULL;
- goto_statement = goto_statement->next) {
- const declaration_t *label = goto_statement->label;
-
- if (label->source_position.input_name == NULL) {
- if (first_err) {
- first_err = false;
- diagnosticf("%s: In function '%Y':\n",
- current_function->source_position.input_name,
- current_function->symbol);
- }
- errorf(goto_statement->statement.source_position,
- "label '%Y' used but not defined", label->symbol);
+ goto_statement != NULL;
+ goto_statement = goto_statement->next) {
+ declaration_t *label = goto_statement->label;
+
+ label->used = true;
+ if (label->source_position.input_name == NULL) {
+ if (first_err) {
+ first_err = false;
+ diagnosticf("%s: In function '%Y':\n",
+ current_function->source_position.input_name,
+ current_function->symbol);
+ }
+ errorf(goto_statement->statement.source_position,
+ "label '%Y' used but not defined", label->symbol);
}
}
goto_first = goto_last = NULL;
+
+ if (warning.unused_label) {
+ for (const label_statement_t *label_statement = label_first;
+ label_statement != NULL;
+ label_statement = label_statement->next) {
+ const declaration_t *label = label_statement->label;
+
+ if (! label->used) {
+ if (first_err) {
+ first_err = false;
+ diagnosticf("%s: In function '%Y':\n",
+ current_function->source_position.input_name,
+ current_function->symbol);
+ }
+ warningf(label_statement->statement.source_position,
+ "label '%Y' defined but not used", label->symbol);
+ }
+ }
+ }
+ label_first = label_last = NULL;
}
static void parse_external_declaration(void)
}
type_t *type = ndeclaration->type;
- if(type == NULL) {
- eat_block();
- return;
- }
/* note that we don't skip typerefs: the standard doesn't allow them here
* (so we can't use is_type_function here) */
if(type->kind != TYPE_FUNCTION) {
- errorf(HERE, "declarator '%#T' has a body but is not a function type",
- type, ndeclaration->symbol);
+ if (is_type_valid(type)) {
+ errorf(HERE, "declarator '%#T' has a body but is not a function type",
+ type, ndeclaration->symbol);
+ }
eat_block();
return;
}
declaration_t *const declaration = record_function_definition(ndeclaration);
if(ndeclaration != declaration) {
- declaration->context = ndeclaration->context;
+ declaration->scope = ndeclaration->scope;
}
type = skip_typeref(declaration->type);
- /* push function parameters and switch context */
- int top = environment_top();
- context_t *last_context = context;
- set_context(&declaration->context);
+ /* push function parameters and switch scope */
+ int top = environment_top();
+ scope_t *last_scope = scope;
+ set_scope(&declaration->scope);
- declaration_t *parameter = declaration->context.declarations;
+ declaration_t *parameter = declaration->scope.declarations;
for( ; parameter != NULL; parameter = parameter->next) {
- if(parameter->parent_context == &ndeclaration->context) {
- parameter->parent_context = context;
+ if(parameter->parent_scope == &ndeclaration->scope) {
+ parameter->parent_scope = scope;
}
- assert(parameter->parent_context == NULL
- || parameter->parent_context == context);
- parameter->parent_context = context;
+ assert(parameter->parent_scope == NULL
+ || parameter->parent_scope == scope);
+ parameter->parent_scope = scope;
environment_push(parameter);
}
current_function = declaration;
declaration->init.statement = parse_compound_statement();
- check_for_missing_labels();
+ check_labels();
assert(current_function == declaration);
current_function = old_current_function;
}
end_of_parse_external_declaration:
- assert(context == &declaration->context);
- set_context(last_context);
+ assert(scope == &declaration->scope);
+ set_scope(last_scope);
environment_pop_to(top);
}
declaration->source_position = token.source_position;
declaration->modifiers = specifiers->decl_modifiers;
declaration->type = type;
-
- record_declaration(declaration);
} else {
declaration = parse_declarator(specifiers,/*may_be_abstract=*/true);
return expression;
}
+/**
+ * Prints an error message if an expression was expected but not read
+ */
static expression_t *expected_expression_error(void)
{
- errorf(HERE, "expected expression, got token '%K'", &token);
-
+ /* skip the error message if the error token was read */
+ if (token.type != T_ERROR) {
+ errorf(HERE, "expected expression, got token '%K'", &token);
+ }
next_token();
return create_invalid_expression();
declaration->type = type;
declaration->symbol = symbol;
declaration->source_position = source_position;
- declaration->parent_context = global_context;
+ declaration->parent_scope = global_scope;
- context_t *old_context = context;
- set_context(global_context);
+ scope_t *old_scope = scope;
+ set_scope(global_scope);
environment_push(declaration);
- /* prepend the declaration to the global declarations list */
- declaration->next = context->declarations;
- context->declarations = declaration;
+ /* prepends the declaration to the global declarations list */
+ declaration->next = scope->declarations;
+ scope->declarations = declaration;
- assert(context == global_context);
- set_context(old_context);
+ assert(scope == global_scope);
+ set_scope(old_scope);
return declaration;
}
*/
static type_t *automatic_type_conversion(type_t *orig_type)
{
- if(orig_type == NULL)
- return NULL;
-
type_t *type = skip_typeref(orig_type);
if(is_type_array(type)) {
array_type_t *array_type = &type->array;
*/
type_t *revert_automatic_type_conversion(const expression_t *expression)
{
- if(expression->base.datatype == NULL)
- return NULL;
+ switch (expression->kind) {
+ case EXPR_REFERENCE: return expression->reference.declaration->type;
+ case EXPR_SELECT: return expression->select.compound_entry->type;
- switch(expression->kind) {
- case EXPR_REFERENCE: {
- const reference_expression_t *ref = &expression->reference;
- return ref->declaration->type;
- }
- case EXPR_SELECT: {
- const select_expression_t *select = &expression->select;
- return select->compound_entry->type;
- }
- case EXPR_UNARY_DEREFERENCE: {
- expression_t *value = expression->unary.value;
- type_t *type = skip_typeref(value->base.datatype);
- pointer_type_t *pointer_type = &type->pointer;
+ case EXPR_UNARY_DEREFERENCE: {
+ const expression_t *const value = expression->unary.value;
+ type_t *const type = skip_typeref(value->base.datatype);
+ assert(is_type_pointer(type));
+ return type->pointer.points_to;
+ }
- return pointer_type->points_to;
- }
- case EXPR_BUILTIN_SYMBOL: {
- const builtin_symbol_expression_t *builtin
- = &expression->builtin_symbol;
- return get_builtin_symbol_type(builtin->symbol);
- }
- case EXPR_ARRAY_ACCESS: {
- const array_access_expression_t *array_access
- = &expression->array_access;
- const expression_t *array_ref = array_access->array_ref;
- type_t *type_left = skip_typeref(array_ref->base.datatype);
- assert(is_type_pointer(type_left));
- pointer_type_t *pointer_type = &type_left->pointer;
- return pointer_type->points_to;
- }
+ case EXPR_BUILTIN_SYMBOL:
+ return get_builtin_symbol_type(expression->builtin_symbol.symbol);
- default:
- break;
+ case EXPR_ARRAY_ACCESS: {
+ const expression_t *const array_ref = expression->array_access.array_ref;
+ type_t *const type_left = skip_typeref(array_ref->base.datatype);
+ if (!is_type_valid(type_left))
+ return type_left;
+ assert(is_type_pointer(type_left));
+ return type_left->pointer.points_to;
+ }
+
+ default: break;
}
return expression->base.datatype;
if(declaration == NULL) {
if (! strict_mode && token.type == '(') {
/* an implicitly defined function */
- warningf(HERE, "implicit declaration of function '%Y'",
- ref->symbol);
+ if (warning.implicit_function_declaration) {
+ warningf(HERE, "implicit declaration of function '%Y'",
+ ref->symbol);
+ }
declaration = create_implicit_function(ref->symbol,
source_position);
{
expression_t *expression = allocate_expression_zero(EXPR_STATEMENT);
- statement_t *statement = parse_compound_statement();
- expression->statement.statement = statement;
- if(statement == NULL) {
- expect(')');
- return NULL;
- }
+ statement_t *statement = parse_compound_statement();
+ expression->statement.statement = statement;
+ expression->base.source_position = statement->base.source_position;
- assert(statement->kind == STATEMENT_COMPOUND);
- compound_statement_t *compound_statement = &statement->compound;
+ /* find last statement and use its type */
+ type_t *type = type_void;
+ const statement_t *stmt = statement->compound.statements;
+ if (stmt != NULL) {
+ while (stmt->base.next != NULL)
+ stmt = stmt->base.next;
- /* find last statement and use it's type */
- const statement_t *last_statement = NULL;
- const statement_t *iter = compound_statement->statements;
- for( ; iter != NULL; iter = iter->base.next) {
- last_statement = iter;
- }
-
- if(last_statement->kind == STATEMENT_EXPRESSION) {
- const expression_statement_t *expression_statement
- = &last_statement->expression;
- expression->base.datatype
- = expression_statement->expression->base.datatype;
+ if (stmt->kind == STATEMENT_EXPRESSION) {
+ type = stmt->expression.expression->base.datatype;
+ }
} else {
- expression->base.datatype = type_void;
+ warningf(expression->base.source_position, "empty statement expression ({})");
}
+ expression->base.datatype = type;
expect(')');
expression->expression.kind = EXPR_FUNCTION;
expression->expression.datatype = type_string;
- expression->value = current_function->symbol->string;
return (expression_t*) expression;
}
expression->expression.kind = EXPR_PRETTY_FUNCTION;
expression->expression.datatype = type_string;
- expression->value = current_function->symbol->string;
return (expression_t*) expression;
}
expression_t *const expr = parse_assignment_expression();
if (expr->kind == EXPR_REFERENCE) {
declaration_t *const decl = expr->reference.declaration;
- if (decl->parent_context == ¤t_function->context &&
+ if (decl->parent_scope == ¤t_function->scope &&
decl->next == NULL) {
expression->va_starte.parameter = decl;
expect(')');
expression->binary.right = parse_assignment_expression();
expect(')');
- type_t *orig_type_left = expression->binary.left->base.datatype;
- type_t *orig_type_right = expression->binary.right->base.datatype;
- if(orig_type_left == NULL || orig_type_right == NULL)
- return expression;
+ type_t *const orig_type_left = expression->binary.left->base.datatype;
+ type_t *const orig_type_right = expression->binary.right->base.datatype;
- type_t *type_left = skip_typeref(orig_type_left);
- type_t *type_right = skip_typeref(orig_type_right);
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
if(!is_type_floating(type_left) && !is_type_floating(type_right)) {
- type_error_incompatible("invalid operands in comparison",
- token.source_position, type_left, type_right);
+ if (is_type_valid(type_left) && is_type_valid(type_right)) {
+ type_error_incompatible("invalid operands in comparison",
+ token.source_position, orig_type_left, orig_type_right);
+ }
} else {
semantic_comparison(&expression->binary);
}
* Check if the expression has the character type and issue a warning then.
*/
static void check_for_char_index_type(const expression_t *expression) {
- type_t *type = expression->base.datatype;
- type_t *base_type = skip_typeref(type);
+ type_t *const type = expression->base.datatype;
+ const type_t *const base_type = skip_typeref(type);
- if (base_type->base.kind == TYPE_ATOMIC) {
- if (base_type->atomic.akind == ATOMIC_TYPE_CHAR) {
- warningf(expression->base.source_position,
- "array subscript has type '%T'", type);
- }
+ if (is_type_atomic(base_type, ATOMIC_TYPE_CHAR) &&
+ warning.char_subscripts) {
+ warningf(expression->base.source_position,
+ "array subscript has type '%T'", type);
}
}
array_access->expression.kind = EXPR_ARRAY_ACCESS;
- type_t *type_left = left->base.datatype;
- type_t *type_inside = inside->base.datatype;
- type_t *return_type = NULL;
-
- if(type_left != NULL && type_inside != NULL) {
- type_left = skip_typeref(type_left);
- type_inside = skip_typeref(type_inside);
-
- if(is_type_pointer(type_left)) {
- pointer_type_t *pointer = &type_left->pointer;
- return_type = pointer->points_to;
- array_access->array_ref = left;
- array_access->index = inside;
- check_for_char_index_type(inside);
- } else if(is_type_pointer(type_inside)) {
- pointer_type_t *pointer = &type_inside->pointer;
- return_type = pointer->points_to;
- array_access->array_ref = inside;
- array_access->index = left;
- array_access->flipped = true;
- check_for_char_index_type(left);
- } else {
- errorf(HERE, "array access on object with non-pointer types '%T', '%T'", type_left, type_inside);
- }
- } else {
+ type_t *const orig_type_left = left->base.datatype;
+ type_t *const orig_type_inside = inside->base.datatype;
+
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_inside = skip_typeref(orig_type_inside);
+
+ type_t *return_type;
+ if (is_type_pointer(type_left)) {
+ return_type = type_left->pointer.points_to;
array_access->array_ref = left;
array_access->index = inside;
+ check_for_char_index_type(inside);
+ } else if (is_type_pointer(type_inside)) {
+ return_type = type_inside->pointer.points_to;
+ array_access->array_ref = inside;
+ array_access->index = left;
+ array_access->flipped = true;
+ check_for_char_index_type(left);
+ } else {
+ if (is_type_valid(type_left) && is_type_valid(type_inside)) {
+ errorf(HERE,
+ "array access on object with non-pointer types '%T', '%T'",
+ orig_type_left, orig_type_inside);
+ }
+ return_type = type_error_type;
+ array_access->array_ref = create_invalid_expression();
}
if(token.type != ']') {
select->select.symbol = symbol;
next_token();
- type_t *orig_type = compound->base.datatype;
- if(orig_type == NULL)
- return create_invalid_expression();
-
- type_t *type = skip_typeref(orig_type);
+ type_t *const orig_type = compound->base.datatype;
+ type_t *const type = skip_typeref(orig_type);
type_t *type_left = type;
if(is_pointer) {
- if(type->kind != TYPE_POINTER) {
- errorf(HERE, "left hand side of '->' is not a pointer, but '%T'", orig_type);
+ if (!is_type_pointer(type)) {
+ if (is_type_valid(type)) {
+ errorf(HERE, "left hand side of '->' is not a pointer, but '%T'", orig_type);
+ }
return create_invalid_expression();
}
- pointer_type_t *pointer_type = &type->pointer;
- type_left = pointer_type->points_to;
+ type_left = type->pointer.points_to;
}
type_left = skip_typeref(type_left);
- if(type_left->kind != TYPE_COMPOUND_STRUCT
- && type_left->kind != TYPE_COMPOUND_UNION) {
- errorf(HERE, "request for member '%Y' in something not a struct or "
- "union, but '%T'", symbol, type_left);
+ if (type_left->kind != TYPE_COMPOUND_STRUCT &&
+ type_left->kind != TYPE_COMPOUND_UNION) {
+ if (is_type_valid(type_left)) {
+ errorf(HERE, "request for member '%Y' in something not a struct or "
+ "union, but '%T'", symbol, type_left);
+ }
return create_invalid_expression();
}
- compound_type_t *compound_type = &type_left->compound;
- declaration_t *declaration = compound_type->declaration;
+ declaration_t *const declaration = type_left->compound.declaration;
if(!declaration->init.is_defined) {
errorf(HERE, "request for member '%Y' of incomplete type '%T'",
return create_invalid_expression();
}
- declaration_t *iter = declaration->context.declarations;
+ declaration_t *iter = declaration->scope.declarations;
for( ; iter != NULL; iter = iter->next) {
if(iter->symbol == symbol) {
break;
call_expression_t *call = &result->call;
call->function = expression;
- function_type_t *function_type = NULL;
- type_t *orig_type = expression->base.datatype;
- if(orig_type != NULL) {
- type_t *type = skip_typeref(orig_type);
-
- if(is_type_pointer(type)) {
- pointer_type_t *pointer_type = &type->pointer;
+ type_t *const orig_type = expression->base.datatype;
+ type_t *const type = skip_typeref(orig_type);
- type = skip_typeref(pointer_type->points_to);
+ function_type_t *function_type = NULL;
+ if (is_type_pointer(type)) {
+ type_t *const to_type = skip_typeref(type->pointer.points_to);
- if (is_type_function(type)) {
- function_type = &type->function;
- call->expression.datatype = function_type->return_type;
- }
+ if (is_type_function(to_type)) {
+ function_type = &to_type->function;
+ call->expression.datatype = function_type->return_type;
}
- if(function_type == NULL) {
- errorf(HERE, "called object '%E' (type '%T') is not a pointer to a function", expression, orig_type);
+ }
- function_type = NULL;
- call->expression.datatype = NULL;
- }
+ if (function_type == NULL && is_type_valid(type)) {
+ errorf(HERE, "called object '%E' (type '%T') is not a pointer to a function", expression, orig_type);
}
/* parse arguments */
for( ; parameter != NULL && argument != NULL;
parameter = parameter->next, argument = argument->next) {
type_t *expected_type = parameter->type;
- /* TODO report context in error messages */
- argument->expression = create_implicit_cast(argument->expression,
- expected_type);
+ /* TODO report scope in error messages */
+ expression_t *const arg_expr = argument->expression;
+ type_t *const res_type = semantic_assign(expected_type, arg_expr, "function call");
+ if (res_type == NULL) {
+ /* TODO improve error message */
+ errorf(arg_expr->base.source_position,
+ "Cannot call function with argument '%E' of type '%T' where type '%T' is expected",
+ arg_expr, arg_expr->base.datatype, expected_type);
+ } else {
+ argument->expression = create_implicit_cast(argument->expression, expected_type);
+ }
}
/* too few parameters */
if(parameter != NULL) {
for( ; argument != NULL; argument = argument->next) {
type_t *type = argument->expression->base.datatype;
- if(type == NULL)
- continue;
-
type = skip_typeref(type);
if(is_type_integer(type)) {
type = promote_integer(type);
static bool same_compound_type(const type_t *type1, const type_t *type2)
{
- if(!is_type_compound(type1))
- return false;
- if(type1->kind != type2->kind)
- return false;
-
- const compound_type_t *compound1 = &type1->compound;
- const compound_type_t *compound2 = &type2->compound;
-
- return compound1->declaration == compound2->declaration;
+ return
+ is_type_compound(type1) &&
+ type1->kind == type2->kind &&
+ type1->compound.declaration == type2->compound.declaration;
}
/**
conditional->condition = expression;
/* 6.5.15.2 */
- type_t *condition_type_orig = expression->base.datatype;
- if(condition_type_orig != NULL) {
- type_t *condition_type = skip_typeref(condition_type_orig);
- if(condition_type != NULL && !is_type_scalar(condition_type)) {
- type_error("expected a scalar type in conditional condition",
- expression->base.source_position, condition_type_orig);
- }
+ type_t *const condition_type_orig = expression->base.datatype;
+ type_t *const condition_type = skip_typeref(condition_type_orig);
+ if (!is_type_scalar(condition_type) && is_type_valid(condition_type)) {
+ type_error("expected a scalar type in conditional condition",
+ expression->base.source_position, condition_type_orig);
}
expression_t *true_expression = parse_expression();
conditional->true_expression = true_expression;
conditional->false_expression = false_expression;
- type_t *orig_true_type = true_expression->base.datatype;
- type_t *orig_false_type = false_expression->base.datatype;
- if(orig_true_type == NULL || orig_false_type == NULL)
- return result;
-
- type_t *true_type = skip_typeref(orig_true_type);
- type_t *false_type = skip_typeref(orig_false_type);
+ type_t *const orig_true_type = true_expression->base.datatype;
+ type_t *const orig_false_type = false_expression->base.datatype;
+ type_t *const true_type = skip_typeref(orig_true_type);
+ type_t *const false_type = skip_typeref(orig_false_type);
/* 6.5.15.3 */
- type_t *result_type = NULL;
+ type_t *result_type;
if (is_type_arithmetic(true_type) && is_type_arithmetic(false_type)) {
result_type = semantic_arithmetic(true_type, false_type);
conditional->true_expression = true_expression;
conditional->false_expression = false_expression;
conditional->expression.datatype = result_type;
- } else if (same_compound_type(true_type, false_type)
- || (is_type_atomic(true_type, ATOMIC_TYPE_VOID) &&
- is_type_atomic(false_type, ATOMIC_TYPE_VOID))) {
+ } else if (same_compound_type(true_type, false_type) || (
+ is_type_atomic(true_type, ATOMIC_TYPE_VOID) &&
+ is_type_atomic(false_type, ATOMIC_TYPE_VOID)
+ )) {
/* just take 1 of the 2 types */
result_type = true_type;
} else if (is_type_pointer(true_type) && is_type_pointer(false_type)
result_type = true_type;
} else {
/* TODO */
- type_error_incompatible("while parsing conditional",
- expression->base.source_position, true_type,
- false_type);
+ if (is_type_valid(true_type) && is_type_valid(false_type)) {
+ type_error_incompatible("while parsing conditional",
+ expression->base.source_position, true_type,
+ false_type);
+ }
+ result_type = type_error_type;
}
conditional->expression.datatype = result_type;
static void semantic_incdec(unary_expression_t *expression)
{
- type_t *orig_type = expression->value->base.datatype;
- if(orig_type == NULL)
- return;
-
- type_t *type = skip_typeref(orig_type);
+ type_t *const orig_type = expression->value->base.datatype;
+ type_t *const type = skip_typeref(orig_type);
+ /* TODO !is_type_real && !is_type_pointer */
if(!is_type_arithmetic(type) && type->kind != TYPE_POINTER) {
- /* TODO: improve error message */
- errorf(HERE, "operation needs an arithmetic or pointer type");
+ if (is_type_valid(type)) {
+ /* TODO: improve error message */
+ errorf(HERE, "operation needs an arithmetic or pointer type");
+ }
return;
}
static void semantic_unexpr_arithmetic(unary_expression_t *expression)
{
- type_t *orig_type = expression->value->base.datatype;
- if(orig_type == NULL)
- return;
-
- type_t *type = skip_typeref(orig_type);
+ type_t *const orig_type = expression->value->base.datatype;
+ type_t *const type = skip_typeref(orig_type);
if(!is_type_arithmetic(type)) {
- /* TODO: improve error message */
- errorf(HERE, "operation needs an arithmetic type");
+ if (is_type_valid(type)) {
+ /* TODO: improve error message */
+ errorf(HERE, "operation needs an arithmetic type");
+ }
return;
}
static void semantic_unexpr_scalar(unary_expression_t *expression)
{
- type_t *orig_type = expression->value->base.datatype;
- if(orig_type == NULL)
- return;
-
- type_t *type = skip_typeref(orig_type);
+ type_t *const orig_type = expression->value->base.datatype;
+ type_t *const type = skip_typeref(orig_type);
if (!is_type_scalar(type)) {
- errorf(HERE, "operand of ! must be of scalar type");
+ if (is_type_valid(type)) {
+ errorf(HERE, "operand of ! must be of scalar type");
+ }
return;
}
static void semantic_unexpr_integer(unary_expression_t *expression)
{
- type_t *orig_type = expression->value->base.datatype;
- if(orig_type == NULL)
- return;
-
- type_t *type = skip_typeref(orig_type);
+ type_t *const orig_type = expression->value->base.datatype;
+ type_t *const type = skip_typeref(orig_type);
if (!is_type_integer(type)) {
- errorf(HERE, "operand of ~ must be of integer type");
+ if (is_type_valid(type)) {
+ errorf(HERE, "operand of ~ must be of integer type");
+ }
return;
}
static void semantic_dereference(unary_expression_t *expression)
{
- type_t *orig_type = expression->value->base.datatype;
- if(orig_type == NULL)
- return;
-
- type_t *type = skip_typeref(orig_type);
+ type_t *const orig_type = expression->value->base.datatype;
+ type_t *const type = skip_typeref(orig_type);
if(!is_type_pointer(type)) {
- errorf(HERE, "Unary '*' needs pointer or arrray type, but type '%T' given", orig_type);
+ if (is_type_valid(type)) {
+ errorf(HERE, "Unary '*' needs pointer or arrray type, but type '%T' given", orig_type);
+ }
return;
}
- pointer_type_t *pointer_type = &type->pointer;
- type_t *result_type = pointer_type->points_to;
-
+ type_t *result_type = type->pointer.points_to;
result_type = automatic_type_conversion(result_type);
expression->expression.datatype = result_type;
}
value->base.datatype = revert_automatic_type_conversion(value);
type_t *orig_type = value->base.datatype;
- if(orig_type == NULL)
+ if(!is_type_valid(orig_type))
return;
if(value->kind == EXPR_REFERENCE) {
- reference_expression_t *reference = (reference_expression_t*) value;
- declaration_t *declaration = reference->declaration;
+ declaration_t *const declaration = value->reference.declaration;
if(declaration != NULL) {
if (declaration->storage_class == STORAGE_CLASS_REGISTER) {
errorf(expression->expression.source_position,
*/
static void semantic_binexpr_arithmetic(binary_expression_t *expression)
{
- expression_t *left = expression->left;
- expression_t *right = expression->right;
- type_t *orig_type_left = left->base.datatype;
- type_t *orig_type_right = right->base.datatype;
-
- if(orig_type_left == NULL || orig_type_right == NULL)
- return;
-
- type_t *type_left = skip_typeref(orig_type_left);
- type_t *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.datatype;
+ type_t *const orig_type_right = right->base.datatype;
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
if(!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
/* TODO: improve error message */
- errorf(HERE, "operation needs arithmetic types");
+ if (is_type_valid(type_left) && is_type_valid(type_right)) {
+ errorf(HERE, "operation needs arithmetic types");
+ }
return;
}
static void semantic_shift_op(binary_expression_t *expression)
{
- expression_t *left = expression->left;
- expression_t *right = expression->right;
- type_t *orig_type_left = left->base.datatype;
- type_t *orig_type_right = right->base.datatype;
-
- if(orig_type_left == NULL || orig_type_right == NULL)
- return;
-
- type_t *type_left = skip_typeref(orig_type_left);
- type_t *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.datatype;
+ type_t *const orig_type_right = right->base.datatype;
+ type_t * type_left = skip_typeref(orig_type_left);
+ type_t * type_right = skip_typeref(orig_type_right);
if(!is_type_integer(type_left) || !is_type_integer(type_right)) {
/* TODO: improve error message */
- errorf(HERE, "operation needs integer types");
+ if (is_type_valid(type_left) && is_type_valid(type_right)) {
+ errorf(HERE, "operation needs integer types");
+ }
return;
}
static void semantic_add(binary_expression_t *expression)
{
- expression_t *left = expression->left;
- expression_t *right = expression->right;
- type_t *orig_type_left = left->base.datatype;
- type_t *orig_type_right = right->base.datatype;
-
- if(orig_type_left == NULL || orig_type_right == NULL)
- return;
-
- type_t *type_left = skip_typeref(orig_type_left);
- type_t *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.datatype;
+ type_t *const orig_type_right = right->base.datatype;
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
/* ยง 5.6.5 */
if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
expression->expression.datatype = type_left;
} else if(is_type_pointer(type_right) && is_type_integer(type_left)) {
expression->expression.datatype = type_right;
- } else {
+ } else if (is_type_valid(type_left) && is_type_valid(type_right)) {
errorf(HERE, "invalid operands to binary + ('%T', '%T')", orig_type_left, orig_type_right);
}
}
static void semantic_sub(binary_expression_t *expression)
{
- expression_t *left = expression->left;
- expression_t *right = expression->right;
- type_t *orig_type_left = left->base.datatype;
- type_t *orig_type_right = right->base.datatype;
-
- if(orig_type_left == NULL || orig_type_right == NULL)
- return;
-
- type_t *type_left = skip_typeref(orig_type_left);
- type_t *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.datatype;
+ type_t *const orig_type_right = right->base.datatype;
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
/* ยง 5.6.5 */
if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
expression->expression.datatype = type_left;
} else if(is_type_pointer(type_left) && is_type_pointer(type_right)) {
if(!pointers_compatible(type_left, type_right)) {
- errorf(HERE, "pointers to incompatible objects to binary - ('%T', '%T')", orig_type_left, orig_type_right);
+ errorf(HERE, "pointers to incompatible objects to binary '-' ('%T', '%T')", orig_type_left, orig_type_right);
} else {
expression->expression.datatype = type_ptrdiff_t;
}
- } else {
- errorf(HERE, "invalid operands to binary - ('%T', '%T')", orig_type_left, orig_type_right);
+ } else if (is_type_valid(type_left) && is_type_valid(type_right)) {
+ errorf(HERE, "invalid operands to binary '-' ('%T', '%T')", orig_type_left, orig_type_right);
}
}
+/**
+ * Check the semantics of comparison expressions.
+ *
+ * @param expression The expression to check.
+ */
static void semantic_comparison(binary_expression_t *expression)
{
expression_t *left = expression->left;
type_t *orig_type_left = left->base.datatype;
type_t *orig_type_right = right->base.datatype;
- if(orig_type_left == NULL || orig_type_right == NULL)
- return;
-
type_t *type_left = skip_typeref(orig_type_left);
type_t *type_right = skip_typeref(orig_type_right);
expression->left = create_implicit_cast(left, arithmetic_type);
expression->right = create_implicit_cast(right, arithmetic_type);
expression->expression.datatype = arithmetic_type;
+ if (warning.float_equal &&
+ (expression->expression.kind == EXPR_BINARY_EQUAL ||
+ expression->expression.kind == EXPR_BINARY_NOTEQUAL) &&
+ is_type_floating(arithmetic_type)) {
+ warningf(expression->expression.source_position,
+ "comparing floating point with == or != is unsafe");
+ }
} else if (is_type_pointer(type_left) && is_type_pointer(type_right)) {
/* TODO check compatibility */
} else if (is_type_pointer(type_left)) {
expression->right = create_implicit_cast(right, type_left);
} else if (is_type_pointer(type_right)) {
expression->left = create_implicit_cast(left, type_right);
- } else {
+ } else if (is_type_valid(type_left) && is_type_valid(type_right)) {
type_error_incompatible("invalid operands in comparison",
- token.source_position, type_left, type_right);
+ expression->expression.source_position,
+ type_left, type_right);
}
expression->expression.datatype = type_int;
}
type_t *orig_type_left = left->base.datatype;
type_t *orig_type_right = right->base.datatype;
- if(orig_type_left == NULL || orig_type_right == NULL)
- return;
-
type_t *type_left = skip_typeref(orig_type_left);
type_t *type_right = skip_typeref(orig_type_right);
if(!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
/* TODO: improve error message */
- errorf(HERE, "operation needs arithmetic types");
+ if (is_type_valid(type_left) && is_type_valid(type_right)) {
+ errorf(HERE, "operation needs arithmetic types");
+ }
return;
}
static void semantic_arithmetic_addsubb_assign(binary_expression_t *expression)
{
- expression_t *left = expression->left;
- expression_t *right = expression->right;
- type_t *orig_type_left = left->base.datatype;
- type_t *orig_type_right = right->base.datatype;
-
- if(orig_type_left == NULL || orig_type_right == NULL)
- return;
-
- type_t *type_left = skip_typeref(orig_type_left);
- type_t *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.datatype;
+ type_t *const orig_type_right = right->base.datatype;
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
if (is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
/* combined instructions are tricky. We can't create an implicit cast on
expression->expression.datatype = type_left;
} else if (is_type_pointer(type_left) && is_type_integer(type_right)) {
expression->expression.datatype = type_left;
- } else {
+ } 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);
- return;
}
}
*/
static void semantic_logical_op(binary_expression_t *expression)
{
- expression_t *left = expression->left;
- expression_t *right = expression->right;
- type_t *orig_type_left = left->base.datatype;
- type_t *orig_type_right = right->base.datatype;
-
- if(orig_type_left == NULL || orig_type_right == NULL)
- return;
-
- type_t *type_left = skip_typeref(orig_type_left);
- type_t *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.datatype;
+ type_t *const orig_type_right = right->base.datatype;
+ type_t *const type_left = skip_typeref(orig_type_left);
+ type_t *const type_right = skip_typeref(orig_type_right);
if (!is_type_scalar(type_left) || !is_type_scalar(type_right)) {
/* TODO: improve error message */
- errorf(HERE, "operation needs scalar types");
+ if (is_type_valid(type_left) && is_type_valid(type_right)) {
+ errorf(HERE, "operation needs scalar types");
+ }
return;
}
*/
static bool has_const_fields(const compound_type_t *type)
{
- const context_t *context = &type->declaration->context;
- const declaration_t *declaration = context->declarations;
+ const scope_t *scope = &type->declaration->scope;
+ const declaration_t *declaration = scope->declarations;
for (; declaration != NULL; declaration = declaration->next) {
if (declaration->namespc != NAMESPACE_NORMAL)
expression_t *left = expression->left;
type_t *orig_type_left = left->base.datatype;
- if(orig_type_left == NULL)
- return;
-
type_t *type_left = revert_automatic_type_conversion(left);
type_left = skip_typeref(orig_type_left);
return;
}
- semantic_assign(orig_type_left, &expression->right, "assignment");
+ type_t *const res_type = semantic_assign(orig_type_left, expression->right,
+ "assignment");
+ if (res_type == NULL) {
+ errorf(expression->expression.source_position,
+ "cannot assign to '%T' from '%T'",
+ orig_type_left, expression->right->base.datatype);
+ } else {
+ expression->right = create_implicit_cast(expression->right, res_type);
+ }
expression->expression.datatype = orig_type_left;
}
+static bool expression_has_effect(const expression_t *const expr)
+{
+ switch (expr->kind) {
+ case EXPR_UNKNOWN: break;
+ case EXPR_INVALID: break;
+ case EXPR_REFERENCE: return false;
+ case EXPR_CONST: return false;
+ case EXPR_STRING_LITERAL: return false;
+ case EXPR_WIDE_STRING_LITERAL: return false;
+ case EXPR_CALL: {
+ const call_expression_t *const call = &expr->call;
+ if (call->function->kind != EXPR_BUILTIN_SYMBOL)
+ return true;
+
+ switch (call->function->builtin_symbol.symbol->ID) {
+ case T___builtin_va_end: return true;
+ default: return false;
+ }
+ }
+ case EXPR_CONDITIONAL: {
+ const conditional_expression_t *const cond = &expr->conditional;
+ return
+ expression_has_effect(cond->true_expression) &&
+ expression_has_effect(cond->false_expression);
+ }
+ case EXPR_SELECT: return false;
+ case EXPR_ARRAY_ACCESS: return false;
+ case EXPR_SIZEOF: return false;
+ case EXPR_CLASSIFY_TYPE: return false;
+ case EXPR_ALIGNOF: return false;
+
+ case EXPR_FUNCTION: return false;
+ case EXPR_PRETTY_FUNCTION: return false;
+ case EXPR_BUILTIN_SYMBOL: break; /* handled in EXPR_CALL */
+ case EXPR_BUILTIN_CONSTANT_P: return false;
+ case EXPR_BUILTIN_PREFETCH: return true;
+ case EXPR_OFFSETOF: return false;
+ case EXPR_VA_START: return true;
+ case EXPR_VA_ARG: return true;
+ case EXPR_STATEMENT: return true; // TODO
+
+ case EXPR_UNARY_NEGATE: return false;
+ case EXPR_UNARY_PLUS: return false;
+ case EXPR_UNARY_BITWISE_NEGATE: return false;
+ case EXPR_UNARY_NOT: return false;
+ case EXPR_UNARY_DEREFERENCE: return false;
+ case EXPR_UNARY_TAKE_ADDRESS: return false;
+ case EXPR_UNARY_POSTFIX_INCREMENT: return true;
+ case EXPR_UNARY_POSTFIX_DECREMENT: return true;
+ case EXPR_UNARY_PREFIX_INCREMENT: return true;
+ case EXPR_UNARY_PREFIX_DECREMENT: return true;
+ case EXPR_UNARY_CAST:
+ return is_type_atomic(expr->base.datatype, ATOMIC_TYPE_VOID);
+ case EXPR_UNARY_CAST_IMPLICIT: return true;
+ case EXPR_UNARY_ASSUME: return true;
+ case EXPR_UNARY_BITFIELD_EXTRACT: return false;
+
+ case EXPR_BINARY_ADD: return false;
+ case EXPR_BINARY_SUB: return false;
+ case EXPR_BINARY_MUL: return false;
+ case EXPR_BINARY_DIV: return false;
+ case EXPR_BINARY_MOD: return false;
+ case EXPR_BINARY_EQUAL: return false;
+ case EXPR_BINARY_NOTEQUAL: return false;
+ case EXPR_BINARY_LESS: return false;
+ case EXPR_BINARY_LESSEQUAL: return false;
+ case EXPR_BINARY_GREATER: return false;
+ case EXPR_BINARY_GREATEREQUAL: return false;
+ case EXPR_BINARY_BITWISE_AND: return false;
+ case EXPR_BINARY_BITWISE_OR: return false;
+ case EXPR_BINARY_BITWISE_XOR: return false;
+ case EXPR_BINARY_SHIFTLEFT: return false;
+ case EXPR_BINARY_SHIFTRIGHT: return false;
+ case EXPR_BINARY_ASSIGN: return true;
+ case EXPR_BINARY_MUL_ASSIGN: return true;
+ case EXPR_BINARY_DIV_ASSIGN: return true;
+ case EXPR_BINARY_MOD_ASSIGN: return true;
+ case EXPR_BINARY_ADD_ASSIGN: return true;
+ case EXPR_BINARY_SUB_ASSIGN: return true;
+ case EXPR_BINARY_SHIFTLEFT_ASSIGN: return true;
+ case EXPR_BINARY_SHIFTRIGHT_ASSIGN: return true;
+ case EXPR_BINARY_BITWISE_AND_ASSIGN: return true;
+ case EXPR_BINARY_BITWISE_XOR_ASSIGN: return true;
+ case EXPR_BINARY_BITWISE_OR_ASSIGN: return true;
+ case EXPR_BINARY_LOGICAL_AND:
+ case EXPR_BINARY_LOGICAL_OR:
+ case EXPR_BINARY_COMMA:
+ return expression_has_effect(expr->binary.right);
+
+ case EXPR_BINARY_BUILTIN_EXPECT: return true;
+ case EXPR_BINARY_ISGREATER: return false;
+ case EXPR_BINARY_ISGREATEREQUAL: return false;
+ case EXPR_BINARY_ISLESS: return false;
+ case EXPR_BINARY_ISLESSEQUAL: return false;
+ case EXPR_BINARY_ISLESSGREATER: return false;
+ case EXPR_BINARY_ISUNORDERED: return false;
+ }
+
+ panic("unexpected statement");
+}
+
static void semantic_comma(binary_expression_t *expression)
{
+ if (warning.unused_value) {
+ const expression_t *const left = expression->left;
+ if (!expression_has_effect(left)) {
+ warningf(left->base.source_position, "left-hand operand of comma expression has no effect");
+ }
+ }
expression->expression.datatype = expression->right->base.datatype;
}
/* if we found a label in the same function, then we already created the
* declaration */
if(candidate != NULL
- && candidate->parent_context == ¤t_function->context) {
+ && candidate->parent_scope == ¤t_function->scope) {
return candidate;
}
errorf(HERE, "label at end of compound statement");
return (statement_t*) label_statement;
} else {
- label_statement->label_statement = parse_statement();
+ if (token.type == ';') {
+ /* eat an empty statement here, to avoid the warning about an empty
+ * after a label. label:; is commonly used to have a label before
+ * a }. */
+ next_token();
+ } else {
+ label_statement->label_statement = parse_statement();
+ }
+ }
+
+ /* remember the labels's in a list for later checking */
+ if (label_last == NULL) {
+ label_first = label_last = label_statement;
+ } else {
+ label_last->next = label_statement;
}
return (statement_t*) label_statement;
expect('(');
expression_t *const expr = parse_expression();
- type_t *const type = promote_integer(skip_typeref(expr->base.datatype));
+ type_t * type = skip_typeref(expr->base.datatype);
+ if (is_type_integer(type)) {
+ type = promote_integer(type);
+ } else if (is_type_valid(type)) {
+ errorf(expr->base.source_position, "switch quantity is not an integer, but '%T'", type);
+ type = type_error_type;
+ }
statement->expression = create_implicit_cast(expr, type);
expect(')');
statement->body = parse_statement();
current_switch = rem;
+ if (warning.switch_default && find_default_label(statement) == NULL) {
+ warningf(statement->statement.source_position, "switch has no default case");
+ }
+
return (statement_t*) statement;
}
expect('(');
- int top = environment_top();
- context_t *last_context = context;
- set_context(&statement->context);
+ int top = environment_top();
+ scope_t *last_scope = scope;
+ set_scope(&statement->scope);
if(token.type != ';') {
if(is_declaration_specifier(&token, false)) {
expect(')');
statement->body = parse_loop_body((statement_t*)statement);
- assert(context == &statement->context);
- set_context(last_context);
+ assert(scope == &statement->scope);
+ set_scope(last_scope);
environment_pop_to(top);
return (statement_t*) statement;
*/
static statement_t *parse_continue(void)
{
- statement_base_t *statement;
+ statement_t *statement;
if (current_loop == NULL) {
errorf(HERE, "continue statement not within loop");
statement = NULL;
} else {
- statement = allocate_ast_zero(sizeof(statement[0]));
- statement->kind = STATEMENT_CONTINUE;
- statement->source_position = token.source_position;
+ statement = allocate_statement_zero(STATEMENT_CONTINUE);
+
+ statement->base.source_position = token.source_position;
}
eat(T_continue);
expect(';');
- return (statement_t*)statement;
+ return statement;
}
/**
*/
static statement_t *parse_break(void)
{
- statement_base_t *statement;
+ statement_t *statement;
if (current_switch == NULL && current_loop == NULL) {
errorf(HERE, "break statement not within loop or switch");
statement = NULL;
} else {
- statement = allocate_ast_zero(sizeof(statement[0]));
- statement->kind = STATEMENT_BREAK;
- statement->source_position = token.source_position;
+ statement = allocate_statement_zero(STATEMENT_BREAK);
+
+ statement->base.source_position = token.source_position;
}
eat(T_break);
expect(';');
- return (statement_t*)statement;
+ return statement;
}
/**
statement->statement.kind = STATEMENT_RETURN;
statement->statement.source_position = token.source_position;
- assert(is_type_function(current_function->type));
- function_type_t *function_type = ¤t_function->type->function;
- type_t *return_type = function_type->return_type;
-
expression_t *return_value = NULL;
if(token.type != ';') {
return_value = parse_expression();
}
expect(';');
- if(return_type == NULL)
- return (statement_t*) statement;
- if(return_value != NULL && return_value->base.datatype == NULL)
- return (statement_t*) statement;
-
- return_type = skip_typeref(return_type);
+ const type_t *const func_type = current_function->type;
+ assert(is_type_function(func_type));
+ type_t *const return_type = skip_typeref(func_type->function.return_type);
if(return_value != NULL) {
type_t *return_value_type = skip_typeref(return_value->base.datatype);
"'return' with a value, in function returning void");
return_value = NULL;
} else {
- if(return_type != NULL) {
- semantic_assign(return_type, &return_value, "'return'");
+ type_t *const res_type = semantic_assign(return_type,
+ return_value, "'return'");
+ if (res_type == NULL) {
+ errorf(statement->statement.source_position,
+ "cannot return something of type '%T' in function returning '%T'",
+ return_value->base.datatype, return_type);
+ } else {
+ return_value = create_implicit_cast(return_value, res_type);
}
}
/* check for returning address of a local var */
parse_declaration(record_declaration);
if(before == NULL) {
- statement->declaration.declarations_begin = context->declarations;
+ statement->declaration.declarations_begin = scope->declarations;
} else {
statement->declaration.declarations_begin = before->next;
}
statement_t *statement = allocate_statement_zero(STATEMENT_EXPRESSION);
statement->base.source_position = token.source_position;
- statement->expression.expression = parse_expression();
+ expression_t *const expr = parse_expression();
+ statement->expression.expression = expr;
+
+ if (warning.unused_value && !expression_has_effect(expr)) {
+ warningf(expr->base.source_position, "statement has no effect");
+ }
expect(';');
break;
case ';':
+ if (warning.empty_statement) {
+ warningf(HERE, "statement is empty");
+ }
next_token();
statement = NULL;
break;
*/
static statement_t *parse_compound_statement(void)
{
- compound_statement_t *compound_statement
+ compound_statement_t *const compound_statement
= allocate_ast_zero(sizeof(compound_statement[0]));
compound_statement->statement.kind = STATEMENT_COMPOUND;
compound_statement->statement.source_position = token.source_position;
eat('{');
- int top = environment_top();
- context_t *last_context = context;
- set_context(&compound_statement->context);
+ int top = environment_top();
+ scope_t *last_scope = scope;
+ set_scope(&compound_statement->scope);
statement_t *last_statement = NULL;
errorf(compound_statement->statement.source_position, "end of file while looking for closing '}'");
}
- assert(context == &compound_statement->context);
- set_context(last_context);
+ assert(scope == &compound_statement->scope);
+ set_scope(last_scope);
environment_pop_to(top);
return (statement_t*) compound_statement;
{
translation_unit_t *unit = allocate_ast_zero(sizeof(unit[0]));
- assert(global_context == NULL);
- global_context = &unit->context;
+ assert(global_scope == NULL);
+ global_scope = &unit->scope;
- assert(context == NULL);
- set_context(&unit->context);
+ assert(scope == NULL);
+ set_scope(&unit->scope);
initialize_builtin_types();
}
}
- assert(context == &unit->context);
- context = NULL;
+ assert(scope == &unit->scope);
+ scope = NULL;
last_declaration = NULL;
- assert(global_context == &unit->context);
- global_context = NULL;
+ assert(global_scope == &unit->scope);
+ global_scope = NULL;
return unit;
}
projects / cparser / blobdiff