+ if(token.type != ',')
+ break;
+ next_token();
+ }
+ }
+ expect(')');
+
+ if(function_type != NULL) {
+ function_parameter_t *parameter = function_type->parameters;
+ call_argument_t *argument = call->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);
+ }
+ /* too few parameters */
+ if(parameter != NULL) {
+ parser_print_error_prefix();
+ fprintf(stderr, "too few arguments to function '");
+ print_expression(expression);
+ fprintf(stderr, "'\n");
+ } else if(argument != NULL) {
+ /* too many parameters */
+ if(!function_type->variadic
+ && !function_type->unspecified_parameters) {
+ parser_print_error_prefix();
+ fprintf(stderr, "too many arguments to function '");
+ print_expression(expression);
+ fprintf(stderr, "'\n");
+ } else {
+ /* do default promotion */
+ 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);
+ } else if(type == type_float) {
+ type = type_double;
+ }
+
+ argument->expression
+ = create_implicit_cast(argument->expression, type);
+ }
+ }
+ }
+ }
+
+ return result;
+}
+
+static type_t *semantic_arithmetic(type_t *type_left, type_t *type_right);
+
+static bool same_compound_type(const type_t *type1, const type_t *type2)
+{
+ if(!is_type_compound(type1))
+ return false;
+ if(type1->type != type2->type)
+ return false;
+
+ const compound_type_t *compound1 = &type1->compound;
+ const compound_type_t *compound2 = &type2->compound;
+
+ return compound1->declaration == compound2->declaration;
+}
+
+static expression_t *parse_conditional_expression(unsigned precedence,
+ expression_t *expression)
+{
+ eat('?');
+
+ expression_t *result = allocate_expression_zero(EXPR_CONDITIONAL);
+
+ conditional_expression_t *conditional = &result->conditional;
+ 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);
+ }
+ }
+
+ expression_t *true_expression = parse_expression();
+ expect(':');
+ expression_t *false_expression = parse_sub_expression(precedence);
+
+ 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);
+
+ /* 6.5.15.3 */
+ type_t *result_type = NULL;
+ if (is_type_arithmetic(true_type) && is_type_arithmetic(false_type)) {
+ result_type = semantic_arithmetic(true_type, false_type);
+
+ true_expression = create_implicit_cast(true_expression, result_type);
+ false_expression = create_implicit_cast(false_expression, result_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))) {
+ /* just take 1 of the 2 types */
+ result_type = true_type;
+ } else if (is_type_pointer(true_type) && is_type_pointer(false_type)
+ && pointers_compatible(true_type, false_type)) {
+ /* ok */
+ result_type = true_type;
+ } else {
+ /* TODO */
+ type_error_incompatible("while parsing conditional",
+ expression->base.source_position, true_type,
+ false_type);
+ }
+
+ conditional->expression.datatype = result_type;
+ return result;
+}
+
+static expression_t *parse_extension(unsigned precedence)
+{
+ eat(T___extension__);
+
+ /* TODO enable extensions */
+
+ return parse_sub_expression(precedence);
+}
+
+static expression_t *parse_builtin_classify_type(const unsigned precedence)
+{
+ eat(T___builtin_classify_type);
+
+ expression_t *result = allocate_expression_zero(EXPR_CLASSIFY_TYPE);
+ result->base.datatype = type_int;
+
+ expect('(');
+ expression_t *expression = parse_sub_expression(precedence);
+ expect(')');
+ result->classify_type.type_expression = expression;
+
+ return result;
+}
+
+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);
+ if(!is_type_arithmetic(type) && type->type != TYPE_POINTER) {
+ /* TODO: improve error message */
+ parser_print_error_prefix();
+ fprintf(stderr, "operation needs an arithmetic or pointer type\n");
+ return;
+ }
+
+ expression->expression.datatype = orig_type;
+}
+
+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);
+ if(!is_type_arithmetic(type)) {
+ /* TODO: improve error message */
+ parser_print_error_prefix();
+ fprintf(stderr, "operation needs an arithmetic type\n");
+ return;
+ }
+
+ expression->expression.datatype = orig_type;
+}
+
+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);
+ if (!is_type_scalar(type)) {
+ parse_error("operand of ! must be of scalar type\n");
+ return;
+ }
+
+ expression->expression.datatype = orig_type;
+}
+
+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);
+ if (!is_type_integer(type)) {
+ parse_error("operand of ~ must be of integer type\n");
+ return;
+ }
+
+ expression->expression.datatype = orig_type;
+}
+
+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);
+ if(!is_type_pointer(type)) {
+ parser_print_error_prefix();
+ fputs("Unary '*' needs pointer or arrray type, but type ", stderr);
+ print_type_quoted(orig_type);
+ fputs(" given.\n", stderr);
+ return;
+ }
+
+ pointer_type_t *pointer_type = &type->pointer;
+ type_t *result_type = pointer_type->points_to;
+
+ result_type = automatic_type_conversion(result_type);
+ expression->expression.datatype = result_type;
+}
+
+static void semantic_take_addr(unary_expression_t *expression)
+{
+ expression_t *value = expression->value;
+ value->base.datatype = revert_automatic_type_conversion(value);
+
+ type_t *orig_type = value->base.datatype;
+ if(orig_type == NULL)
+ return;
+
+ if(value->type == EXPR_REFERENCE) {
+ reference_expression_t *reference = (reference_expression_t*) value;
+ declaration_t *declaration = reference->declaration;
+ if(declaration != NULL) {
+ declaration->address_taken = 1;
+ }
+ }
+
+ expression->expression.datatype = make_pointer_type(orig_type, TYPE_QUALIFIER_NONE);
+}
+
+#define CREATE_UNARY_EXPRESSION_PARSER(token_type, unexpression_type, sfunc) \
+static expression_t *parse_##unexpression_type(unsigned precedence) \
+{ \
+ eat(token_type); \
+ \
+ expression_t *unary_expression \
+ = allocate_expression_zero(unexpression_type); \
+ unary_expression->unary.value = parse_sub_expression(precedence); \
+ \
+ sfunc(&unary_expression->unary); \
+ \
+ return unary_expression; \
+}
+
+CREATE_UNARY_EXPRESSION_PARSER('-', EXPR_UNARY_NEGATE,
+ semantic_unexpr_arithmetic)
+CREATE_UNARY_EXPRESSION_PARSER('+', EXPR_UNARY_PLUS,
+ semantic_unexpr_arithmetic)
+CREATE_UNARY_EXPRESSION_PARSER('!', EXPR_UNARY_NOT,
+ semantic_unexpr_scalar)
+CREATE_UNARY_EXPRESSION_PARSER('*', EXPR_UNARY_DEREFERENCE,
+ semantic_dereference)
+CREATE_UNARY_EXPRESSION_PARSER('&', EXPR_UNARY_TAKE_ADDRESS,
+ semantic_take_addr)
+CREATE_UNARY_EXPRESSION_PARSER('~', EXPR_UNARY_BITWISE_NEGATE,
+ semantic_unexpr_integer)
+CREATE_UNARY_EXPRESSION_PARSER(T_PLUSPLUS, EXPR_UNARY_PREFIX_INCREMENT,
+ semantic_incdec)
+CREATE_UNARY_EXPRESSION_PARSER(T_MINUSMINUS, EXPR_UNARY_PREFIX_DECREMENT,
+ semantic_incdec)
+
+#define CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(token_type, unexpression_type, \
+ sfunc) \
+static expression_t *parse_##unexpression_type(unsigned precedence, \
+ expression_t *left) \
+{ \
+ (void) precedence; \
+ eat(token_type); \
+ \
+ expression_t *unary_expression \
+ = allocate_expression_zero(unexpression_type); \
+ unary_expression->unary.value = left; \
+ \
+ sfunc(&unary_expression->unary); \
+ \
+ return unary_expression; \
+}
+
+CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(T_PLUSPLUS,
+ EXPR_UNARY_POSTFIX_INCREMENT,
+ semantic_incdec)
+CREATE_UNARY_POSTFIX_EXPRESSION_PARSER(T_MINUSMINUS,
+ EXPR_UNARY_POSTFIX_DECREMENT,
+ semantic_incdec)
+
+static type_t *semantic_arithmetic(type_t *type_left, type_t *type_right)
+{
+ /* TODO: handle complex + imaginary types */
+
+ /* § 6.3.1.8 Usual arithmetic conversions */
+ if(type_left == type_long_double || type_right == type_long_double) {
+ return type_long_double;
+ } else if(type_left == type_double || type_right == type_double) {
+ return type_double;
+ } else if(type_left == type_float || type_right == type_float) {
+ return type_float;
+ }
+
+ type_right = promote_integer(type_right);
+ type_left = promote_integer(type_left);
+
+ if(type_left == type_right)
+ return type_left;
+
+ bool signed_left = is_type_signed(type_left);
+ bool signed_right = is_type_signed(type_right);
+ int rank_left = get_rank(type_left);
+ int rank_right = get_rank(type_right);
+ if(rank_left < rank_right) {
+ if(signed_left == signed_right || !signed_right) {
+ return type_right;
+ } else {
+ return type_left;
+ }
+ } else {
+ if(signed_left == signed_right || !signed_left) {
+ return type_left;
+ } else {
+ return type_right;
+ }
+ }
+}
+
+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);
+
+ if(!is_type_arithmetic(type_left) || !is_type_arithmetic(type_right)) {
+ /* TODO: improve error message */
+ parser_print_error_prefix();
+ fprintf(stderr, "operation needs arithmetic types\n");
+ return;
+ }
+
+ type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
+ expression->left = create_implicit_cast(left, arithmetic_type);
+ expression->right = create_implicit_cast(right, arithmetic_type);
+ expression->expression.datatype = arithmetic_type;
+}
+
+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);
+
+ if(!is_type_integer(type_left) || !is_type_integer(type_right)) {
+ /* TODO: improve error message */
+ parser_print_error_prefix();
+ fprintf(stderr, "operation needs integer types\n");
+ return;
+ }
+
+ type_left = promote_integer(type_left);
+ type_right = promote_integer(type_right);
+
+ expression->left = create_implicit_cast(left, type_left);
+ expression->right = create_implicit_cast(right, type_right);
+ expression->expression.datatype = type_left;
+}
+
+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);
+
+ /* § 5.6.5 */
+ if(is_type_arithmetic(type_left) && is_type_arithmetic(type_right)) {
+ type_t *arithmetic_type = semantic_arithmetic(type_left, type_right);
+ expression->left = create_implicit_cast(left, arithmetic_type);
+ expression->right = create_implicit_cast(right, arithmetic_type);
+ expression->expression.datatype = arithmetic_type;
+ return;
+ } else if(is_type_pointer(type_left) && is_type_integer(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 {
+ parser_print_error_prefix();
+ fprintf(stderr, "invalid operands to binary + (");
+ print_type_quoted(orig_type_left);
+ fprintf(stderr, ", ");
+ print_type_quoted(orig_type_right);
+ fprintf(stderr, ")\n");