From a1871cb3ab3ce7ab44ae7816874c84835787c59c Mon Sep 17 00:00:00 2001 From: Christoph Mallon Date: Tue, 4 Nov 2008 14:34:01 +0000 Subject: [PATCH] Set the source position in allocate_expression_zero(). [r23431] --- parser.c | 158 +++++++++++++++++++++++-------------------------------- 1 file changed, 67 insertions(+), 91 deletions(-) diff --git a/parser.c b/parser.c index 3a3f75d..bc02cfc 100644 --- a/parser.c +++ b/parser.c @@ -443,8 +443,9 @@ static expression_t *allocate_expression_zero(expression_kind_t kind) size_t size = get_expression_struct_size(kind); expression_t *res = allocate_ast_zero(size); - res->base.kind = kind; - res->base.type = type_error_type; + res->base.kind = kind; + res->base.type = type_error_type; + res->base.source_position = token.source_position; return res; } @@ -453,9 +454,7 @@ static expression_t *allocate_expression_zero(expression_kind_t kind) */ static expression_t *create_invalid_expression(void) { - expression_t *expression = allocate_expression_zero(EXPR_INVALID); - expression->base.source_position = token.source_position; - return expression; + return allocate_expression_zero(EXPR_INVALID); } /** @@ -721,7 +720,7 @@ static void eat_block(void) next_token(); } -#define eat(token_type) do { assert(token.type == token_type); next_token(); } while (0) +#define eat(token_type) do { assert(token.type == (token_type)); next_token(); } while (0) /** * Report a parse error because an expected token was not found. @@ -6295,10 +6294,9 @@ static expression_t *parse_string_const(void) */ static expression_t *parse_int_const(void) { - expression_t *cnst = allocate_expression_zero(EXPR_CONST); - cnst->base.source_position = *HERE; - cnst->base.type = token.datatype; - cnst->conste.v.int_value = token.v.intvalue; + expression_t *cnst = allocate_expression_zero(EXPR_CONST); + cnst->base.type = token.datatype; + cnst->conste.v.int_value = token.v.intvalue; next_token(); @@ -6311,10 +6309,8 @@ static expression_t *parse_int_const(void) static expression_t *parse_character_constant(void) { expression_t *cnst = allocate_expression_zero(EXPR_CHARACTER_CONSTANT); - - cnst->base.source_position = *HERE; - cnst->base.type = token.datatype; - cnst->conste.v.character = token.v.string; + cnst->base.type = token.datatype; + cnst->conste.v.character = token.v.string; if (cnst->conste.v.character.size != 1) { if (warning.multichar && GNU_MODE) { @@ -6334,8 +6330,6 @@ static expression_t *parse_character_constant(void) static expression_t *parse_wide_character_constant(void) { expression_t *cnst = allocate_expression_zero(EXPR_WIDE_CHARACTER_CONSTANT); - - cnst->base.source_position = *HERE; cnst->base.type = token.datatype; cnst->conste.v.wide_character = token.v.wide_string; @@ -6746,7 +6740,7 @@ static expression_t *parse_cast(void) source_position_t source_position = token.source_position; - type_t *type = parse_typename(); + type_t *type = parse_typename(); rem_anchor_token(')'); expect(')'); @@ -6780,9 +6774,8 @@ static expression_t *parse_statement_expression(void) expression_t *expression = allocate_expression_zero(EXPR_STATEMENT); - statement_t *statement = parse_compound_statement(true); - expression->statement.statement = statement; - expression->base.source_position = statement->base.source_position; + statement_t *statement = parse_compound_statement(true); + expression->statement.statement = statement; /* find last statement and use its type */ type_t *type = type_void; @@ -6838,7 +6831,6 @@ end_error: static expression_t *parse_function_keyword(void) { - next_token(); /* TODO */ if (current_function == NULL) { @@ -6849,13 +6841,13 @@ static expression_t *parse_function_keyword(void) expression->base.type = type_char_ptr; expression->funcname.kind = FUNCNAME_FUNCTION; + next_token(); + return expression; } static expression_t *parse_pretty_function_keyword(void) { - eat(T___PRETTY_FUNCTION__); - if (current_function == NULL) { errorf(HERE, "'__PRETTY_FUNCTION__' used outside of a function"); } @@ -6864,13 +6856,13 @@ static expression_t *parse_pretty_function_keyword(void) expression->base.type = type_char_ptr; expression->funcname.kind = FUNCNAME_PRETTY_FUNCTION; + eat(T___PRETTY_FUNCTION__); + return expression; } static expression_t *parse_funcsig_keyword(void) { - eat(T___FUNCSIG__); - if (current_function == NULL) { errorf(HERE, "'__FUNCSIG__' used outside of a function"); } @@ -6879,13 +6871,13 @@ static expression_t *parse_funcsig_keyword(void) expression->base.type = type_char_ptr; expression->funcname.kind = FUNCNAME_FUNCSIG; + eat(T___FUNCSIG__); + return expression; } static expression_t *parse_funcdname_keyword(void) { - eat(T___FUNCDNAME__); - if (current_function == NULL) { errorf(HERE, "'__FUNCDNAME__' used outside of a function"); } @@ -6894,6 +6886,8 @@ static expression_t *parse_funcdname_keyword(void) expression->base.type = type_char_ptr; expression->funcname.kind = FUNCNAME_FUNCDNAME; + eat(T___FUNCDNAME__); + return expression; } @@ -6957,11 +6951,11 @@ end_error: */ static expression_t *parse_offsetof(void) { - eat(T___builtin_offsetof); - expression_t *expression = allocate_expression_zero(EXPR_OFFSETOF); expression->base.type = type_size_t; + eat(T___builtin_offsetof); + expect('('); add_anchor_token(','); type_t *type = parse_typename(); @@ -6998,10 +6992,10 @@ end_error: */ static expression_t *parse_va_start(void) { - eat(T___builtin_va_start); - expression_t *expression = allocate_expression_zero(EXPR_VA_START); + eat(T___builtin_va_start); + expect('('); add_anchor_token(','); expression->va_starte.ap = parse_assignment_expression(); @@ -7031,10 +7025,10 @@ end_error: */ static expression_t *parse_va_arg(void) { - eat(T___builtin_va_arg); - expression_t *expression = allocate_expression_zero(EXPR_VA_ARG); + eat(T___builtin_va_arg); + expect('('); expression->va_arge.ap = parse_assignment_expression(); expect(','); @@ -7067,10 +7061,10 @@ static expression_t *parse_builtin_symbol(void) */ static expression_t *parse_builtin_constant(void) { - eat(T___builtin_constant_p); - expression_t *expression = allocate_expression_zero(EXPR_BUILTIN_CONSTANT_P); + eat(T___builtin_constant_p); + expect('('); add_anchor_token(')'); expression->builtin_constant.value = parse_assignment_expression(); @@ -7088,10 +7082,10 @@ end_error: */ static expression_t *parse_builtin_prefetch(void) { - eat(T___builtin_prefetch); - expression_t *expression = allocate_expression_zero(EXPR_BUILTIN_PREFETCH); + eat(T___builtin_prefetch); + expect('('); add_anchor_token(')'); expression->builtin_prefetch.adr = parse_assignment_expression(); @@ -7175,11 +7169,11 @@ end_error: */ static expression_t *parse_builtin_expect(void) { - eat(T___builtin_expect); - expression_t *expression = allocate_expression_zero(EXPR_BINARY_BUILTIN_EXPECT); + eat(T___builtin_expect); + expect('('); expression->binary.left = parse_assignment_expression(); expect(','); @@ -7199,10 +7193,9 @@ end_error: */ static expression_t *parse_assume(void) { - eat(T__assume); + expression_t *expression = allocate_expression_zero(EXPR_UNARY_ASSUME); - expression_t *expression - = allocate_expression_zero(EXPR_UNARY_ASSUME); + eat(T__assume); expect('('); add_anchor_token(')'); @@ -7288,7 +7281,12 @@ end_error: */ static expression_t *parse_noop_expression(void) { - source_position_t source_position = *HERE; + /* the result is a (int)0 */ + expression_t *cnst = allocate_expression_zero(EXPR_CONST); + cnst->base.type = type_int; + cnst->conste.v.int_value = 0; + cnst->conste.is_ms_noop = true; + eat(T___noop); if (token.type == '(') { @@ -7310,17 +7308,8 @@ static expression_t *parse_noop_expression(void) rem_anchor_token(')'); expect(')'); - /* the result is a (int)0 */ - expression_t *cnst = allocate_expression_zero(EXPR_CONST); - cnst->base.source_position = source_position; - cnst->base.type = type_int; - cnst->conste.v.int_value = 0; - cnst->conste.is_ms_noop = true; - - return cnst; - end_error: - return create_invalid_expression(); + return cnst; } /** @@ -7393,22 +7382,21 @@ static void check_for_char_index_type(const expression_t *expression) static expression_t *parse_array_expression(expression_t *left) { + expression_t *expression = allocate_expression_zero(EXPR_ARRAY_ACCESS); + eat('['); add_anchor_token(']'); expression_t *inside = parse_expression(); - expression_t *expression = allocate_expression_zero(EXPR_ARRAY_ACCESS); - - array_access_expression_t *array_access = &expression->array_access; - type_t *const orig_type_left = left->base.type; type_t *const orig_type_inside = inside->base.type; type_t *const type_left = skip_typeref(orig_type_left); type_t *const type_inside = skip_typeref(orig_type_inside); - type_t *return_type; + type_t *return_type; + array_access_expression_t *array_access = &expression->array_access; if (is_type_pointer(type_left)) { return_type = type_left->pointer.points_to; array_access->array_ref = left; @@ -7442,12 +7430,12 @@ static expression_t *parse_array_expression(expression_t *left) return expression; } -static expression_t *parse_typeprop(expression_kind_t const kind, - source_position_t const pos) +static expression_t *parse_typeprop(expression_kind_t const kind) { expression_t *tp_expression = allocate_expression_zero(kind); - tp_expression->base.type = type_size_t; - tp_expression->base.source_position = pos; + tp_expression->base.type = type_size_t; + + eat(kind == EXPR_SIZEOF ? T_sizeof : T___alignof__); char const* const what = kind == EXPR_SIZEOF ? "sizeof" : "alignof"; @@ -7488,7 +7476,8 @@ typeprop_expression: type->kind == TYPE_BITFIELD ? "bitfield" : NULL; if (wrong_type != NULL) { - errorf(&pos, "operand of %s expression must not be of %s type '%T'", + errorf(&tp_expression->base.source_position, + "operand of %s expression must not be of %s type '%T'", what, wrong_type, orig_type); } @@ -7499,28 +7488,23 @@ end_error: static expression_t *parse_sizeof(void) { - source_position_t pos = *HERE; - eat(T_sizeof); - return parse_typeprop(EXPR_SIZEOF, pos); + return parse_typeprop(EXPR_SIZEOF); } static expression_t *parse_alignof(void) { - source_position_t pos = *HERE; - eat(T___alignof__); - return parse_typeprop(EXPR_ALIGNOF, pos); + return parse_typeprop(EXPR_ALIGNOF); } static expression_t *parse_select_expression(expression_t *compound) { - assert(token.type == '.' || token.type == T_MINUSGREATER); + expression_t *select = allocate_expression_zero(EXPR_SELECT); + select->select.compound = compound; + assert(token.type == '.' || token.type == T_MINUSGREATER); bool is_pointer = (token.type == T_MINUSGREATER); next_token(); - expression_t *select = allocate_expression_zero(EXPR_SELECT); - select->select.compound = compound; - if (token.type != T_IDENTIFIER) { parse_error_expected("while parsing select", T_IDENTIFIER, NULL); return select; @@ -7660,11 +7644,9 @@ static void check_call_argument(const function_parameter_t *parameter, */ static expression_t *parse_call_expression(expression_t *expression) { - expression_t *result = allocate_expression_zero(EXPR_CALL); - result->base.source_position = expression->base.source_position; - - call_expression_t *call = &result->call; - call->function = expression; + expression_t *result = allocate_expression_zero(EXPR_CALL); + call_expression_t *call = &result->call; + call->function = expression; type_t *const orig_type = expression->base.type; type_t *const type = skip_typeref(orig_type); @@ -7771,8 +7753,7 @@ static expression_t *parse_conditional_expression(expression_t *expression) expression_t *result = allocate_expression_zero(EXPR_CONDITIONAL); conditional_expression_t *conditional = &result->conditional; - conditional->base.source_position = *HERE; - conditional->condition = expression; + conditional->condition = expression; eat('?'); add_anchor_token(':'); @@ -7925,11 +7906,11 @@ static expression_t *parse_extension(void) */ static expression_t *parse_builtin_classify_type(void) { - eat(T___builtin_classify_type); - expression_t *result = allocate_expression_zero(EXPR_CLASSIFY_TYPE); result->base.type = type_int; + eat(T___builtin_classify_type); + expect('('); add_anchor_token(')'); expression_t *expression = parse_expression(); @@ -7949,8 +7930,7 @@ end_error: static expression_t *parse_delete(void) { expression_t *const result = allocate_expression_zero(EXPR_UNARY_DELETE); - result->base.source_position = *HERE; - result->base.type = type_void; + result->base.type = type_void; eat(T_delete); @@ -7984,8 +7964,7 @@ end_error:; static expression_t *parse_throw(void) { expression_t *const result = allocate_expression_zero(EXPR_UNARY_THROW); - result->base.source_position = *HERE; - result->base.type = type_void; + result->base.type = type_void; eat(T_throw); @@ -8261,7 +8240,6 @@ static expression_t *parse_##unexpression_type(void) \ { \ expression_t *unary_expression \ = allocate_expression_zero(unexpression_type); \ - unary_expression->base.source_position = *HERE; \ eat(token_type); \ unary_expression->unary.value = parse_sub_expression(PREC_UNARY); \ \ @@ -8293,9 +8271,8 @@ static expression_t *parse_##unexpression_type(expression_t *left) \ { \ expression_t *unary_expression \ = allocate_expression_zero(unexpression_type); \ - unary_expression->base.source_position = *HERE; \ eat(token_type); \ - unary_expression->unary.value = left; \ + unary_expression->unary.value = left; \ \ sfunc(&unary_expression->unary); \ \ @@ -8953,8 +8930,7 @@ static void semantic_comma(binary_expression_t *expression) static expression_t *parse_##binexpression_type(expression_t *left) \ { \ expression_t *binexpr = allocate_expression_zero(binexpression_type); \ - binexpr->base.source_position = *HERE; \ - binexpr->binary.left = left; \ + binexpr->binary.left = left; \ eat(token_type); \ \ expression_t *right = parse_sub_expression(prec_r); \ -- 2.20.1