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;
+ type_t *const source_type = expression->base.datatype;
- if(source_type == NULL)
+ if (source_type == dest_type)
return expression;
- source_type = skip_typeref(source_type);
- dest_type = skip_typeref(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;
-
- case TYPE_COMPOUND_STRUCT:
- case TYPE_COMPOUND_UNION:
- case TYPE_ERROR:
- 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 */
const char *context)
{
type_t *const orig_type_right = right->base.datatype;
-
- if (!is_type_valid(orig_type_right))
- return orig_type_right;
-
- type_t *const type_left = skip_typeref(orig_type_left);
- type_t *const 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_arithmetic(type_left) && is_type_arithmetic(type_right)) ||
(is_type_pointer(type_left) && is_null_pointer_constant(right)) ||
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)) {
- return type_error_type;
+ return NULL;
}
return orig_type_left;
}
}
- return type_error_type;
+ 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)
}
type_t *const res_type = semantic_assign(type, expression, "initializer");
- if (!is_type_valid(res_type))
+ if (res_type == NULL)
return NULL;
initializer_t *const result = allocate_initializer_zero(INITIALIZER_VALUE);
if(token.type != '{') {
expression_t *expression = parse_assignment_expression();
- if (expression->base.datatype == NULL) {
- /* something bad happens, don't produce further errors */
- return NULL;
- }
initializer_t *initializer = initializer_from_expression(type, expression);
if(initializer == NULL) {
errorf(HERE,
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) */
}
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;
}
*/
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: {
const reference_expression_t *ref = &expression->reference;
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);
+ 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));
- pointer_type_t *pointer_type = &type_left->pointer;
- return pointer_type->points_to;
+ return type_left->pointer.points_to;
}
default:
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);
}
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)) {
+ pointer_type_t *const 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 *const 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 {
+ 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 = 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();
}
call_expression_t *call = &result->call;
call->function = expression;
- function_type_t *function_type = NULL;
- type_t *orig_type = expression->base.datatype;
- if(is_type_valid(orig_type)) {
- 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( ; 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);
type_t *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_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);
}
}
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->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);
}
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;
}
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);
type_t *const res_type = semantic_assign(orig_type_left, expression->right,
"assignment");
- if (!is_type_valid(res_type)) {
+ if (res_type == NULL) {
errorf(expression->expression.source_position,
"cannot assign to '%T' from '%T'",
orig_type_left, expression->right->base.datatype);
expression->right = create_implicit_cast(expression->right, res_type);
}
- expression->expression.datatype = res_type;
+ expression->expression.datatype = orig_type_left;
}
static void semantic_comma(binary_expression_t *expression)
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(')');
}
expect(';');
- if(!is_type_valid(return_type))
- return (statement_t*) statement;
- if(!is_type_valid(return_value->base.datatype))
- return (statement_t*) statement;
-
return_type = skip_typeref(return_type);
if(return_value != NULL) {
"'return' with a value, in function returning void");
return_value = NULL;
} else {
- if(is_type_valid(return_type)) {
- if (return_value->base.datatype == NULL)
- return (statement_t*)statement;
-
- type_t *const res_type = semantic_assign(return_type,
- return_value, "'return'");
- if (!is_type_valid(res_type)) {
- errorf(statement->statement.source_position,
- "cannot assign to '%T' from '%T'",
- "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);
- }
+ 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 */
projects / cparser / commitdiff