From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: Received: (qmail 694 invoked by alias); 30 Nov 2010 15:33:21 -0000 Received: (qmail 667 invoked by uid 22791); 30 Nov 2010 15:33:15 -0000 X-SWARE-Spam-Status: No, hits=-1.7 required=5.0 tests=AWL,BAYES_00,TW_BJ,TW_FN,T_RP_MATCHES_RCVD X-Spam-Check-By: sourceware.org Received: from fencepost.gnu.org (HELO fencepost.gnu.org) (140.186.70.10) by sourceware.org (qpsmtpd/0.43rc1) with ESMTP; Tue, 30 Nov 2010 15:33:07 +0000 Received: from bonzini by fencepost.gnu.org with local (Exim 4.69) (envelope-from ) id 1PNSCT-0006Ym-Hn; Tue, 30 Nov 2010 10:33:01 -0500 From: Paolo Bonzini To: gcc-patches@gcc.gnu.org Cc: joseph@codesourcery.com Subject: [PATCH v2] PR c/20385: more detection of unknown type names Date: Tue, 30 Nov 2010 17:00:00 -0000 Message-Id: <1291131182-9976-1-git-send-email-bonzini@gnu.org> Mailing-List: contact gcc-patches-help@gcc.gnu.org; run by ezmlm Precedence: bulk List-Id: List-Archive: List-Post: List-Help: Sender: gcc-patches-owner@gcc.gnu.org X-SW-Source: 2010-11/txt/msg02935.txt.bz2 This patch fixes the problems in c_parser_declspecs pointed out by review of v1. The new argument is changed to specify the desired lookahead directly. Bootstrapped/regtested x86_64-pc-linux-gnu. Paolo 2010-11-30 Paolo Bonzini * function.c (used_types_insert): Handle ERROR_MARK. * c-decl.c (grokdeclarator): Handle ERROR_MARK. (declspecs_add_type): Leave error_mark_node in specs->type. (finish_declspecs): Change it to integer_type_node here. * c-parser.c (c_parser_peek_2nd_token): Move earlier. (enum c_lookahead_kind): New. (c_parser_next_token_starts_typename): New name of c_parser_next_tokens_start_typename. Accept lookahead enum and handle it here instead of... (c_parser_next_tokens_start_declaration): ... here. Call it. (c_parser_declspecs): Accept another argument. Do not exit on C_ID_ID if it is guessed to be an unknown typename. (c_parser_parms_declarator): Use 2nd token to distinguish a K&R declaration from an ANSI declaration starting with an unknown typename. (c_parser_struct_declaration, c_parser_objc_type_name, c_parser_typeof_specifier, c_parser_declarator, c_parser_direct_declarator_inner): Adjust calls. (c_parser_parameter_declaration): Likewise. (c_parser_type_name): Pass back an error_mark_node to the caller. (c_parser_postfix_expression): Do error recovery when c_parser_type_name returns NULL. 2010-11-20 Paolo Bonzini * objc.dg/tls/init-2.m: Adjust. * gcc.dg/noncompile/920923-1.c: Adjust. * gcc.dg/noncompile/pr44517.c: Adjust. * gcc.dg/declspec-18.c: New test. Index: gcc/testsuite/objc.dg/tls/init-2.m =================================================================== --- gcc/testsuite/objc.dg/tls/init-2.m (branch diag-2) +++ gcc/testsuite/objc.dg/tls/init-2.m (working copy) @@ -11,4 +11,4 @@ struct S { S(); /* { dg-error "expected specifier-qualifier-list before 'S'" } */ }; -__thread S s; /* { dg-error "expected" } two errors here */ +__thread S s; /* { dg-error "unknown type name" } */ Index: gcc/testsuite/gcc.dg/noncompile/920923-1.c =================================================================== --- gcc/testsuite/gcc.dg/noncompile/920923-1.c (branch diag-2) +++ gcc/testsuite/gcc.dg/noncompile/920923-1.c (working copy) @@ -2,13 +2,13 @@ typedef BYTE unsigned char; /* { dg-error "expected" } */ typedef int item_n; typedef int perm_set; -struct PENT { caddr_t v_addr; };/* { dg-error "expected" } */ +struct PENT { caddr_t v_addr; };/* { dg-error "unknown type name" } */ typedef struct PENT prec; typedef struct PENT *prec_t; prec_t mem_hash; BYTE *mem_base; /* { dg-error "unknown type name" } */ struct PTE { - BYTE *p_page; /* { dg-error "expected" } */ + BYTE *p_page; /* { dg-error "unknown type name" } */ perm_set p_perms; }; typedef struct PTE pte; @@ -56,7 +56,7 @@ int va_op; caddr_t v_addr; /* { dg-error "unknown type name" } */ { register prec_t bucket; - register caddr_t p_addr; /* { dg-error "expected|undeclared" } */ + register caddr_t p_addr; /* { dg-error "unknown type name" } */ bucket = mem_hash+((((v_addr)>>ITEMBITS))&hash_mask); /* { dg-error "undeclared" } */ do { if (bucket->v_addr == ((v_addr)>>ITEMBITS) { /* { dg-error "expected|undeclared|no member" } */ Index: gcc/testsuite/gcc.dg/noncompile/pr44517.c =================================================================== --- gcc/testsuite/gcc.dg/noncompile/pr44517.c (branch diag-2) +++ gcc/testsuite/gcc.dg/noncompile/pr44517.c (working copy) @@ -12,7 +12,7 @@ int f2(int x, lon y, long z, ...){ /* { void f3(int n, int a[n], pid_t x); /* { dg-error "unknown type name 'pid_t'" } */ void f4() {} void f5(int a, *b); /* { dg-error "expected declaration specifiers or" } */ -void f6(int a, b); /* { dg-error "expected declaration specifiers or" } */ +void f6(int a, b); /* { dg-error "unknown type name 'b'" } */ void f7(int a, goto b); /* { dg-error "expected declaration specifiers or" } */ void f8(int a, in goto); /* { dg-error "unknown type name 'in'" } */ void f9(int a, in 1); /* { dg-error "unknown type name 'in'" } */ Index: gcc/function.c =================================================================== --- gcc/function.c (branch diag-2) +++ gcc/function.c (working copy) @@ -5712,6 +5712,8 @@ used_types_insert (tree t) break; else t = TREE_TYPE (t); + if (TREE_CODE (t) == ERROR_MARK) + return; if (TYPE_NAME (t) == NULL_TREE || TYPE_NAME (t) == TYPE_NAME (TYPE_MAIN_VARIANT (t))) t = TYPE_MAIN_VARIANT (t); Index: gcc/c-decl.c =================================================================== --- gcc/c-decl.c (branch diag-2) +++ gcc/c-decl.c (working copy) @@ -4864,6 +4864,8 @@ grokdeclarator (const struct c_declarato tree expr_dummy; bool expr_const_operands_dummy; + if (TREE_CODE (type) == ERROR_MARK) + return error_mark_node; if (expr == NULL) expr = &expr_dummy; if (expr_const_operands == NULL) @@ -9307,9 +9309,9 @@ declspecs_add_type (location_t loc, stru else specs->type = TREE_TYPE (t); } - else if (TREE_CODE (type) != ERROR_MARK) + else { - if (spec.kind == ctsk_typeof) + if (TREE_CODE (type) != ERROR_MARK && spec.kind == ctsk_typeof) { specs->typedef_p = true; if (spec.expr) @@ -9324,11 +9326,6 @@ declspecs_add_type (location_t loc, stru } specs->type = type; } - else - { - /* Set a dummy type here to avoid warning about implicit 'int'. */ - specs->type = integer_type_node; - } return specs; } @@ -9444,6 +9441,10 @@ finish_declspecs (struct c_declspecs *sp gcc_assert (!specs->long_p && !specs->long_long_p && !specs->short_p && !specs->signed_p && !specs->unsigned_p && !specs->complex_p); + + /* Set a dummy type. */ + if (TREE_CODE (specs->type) == ERROR_MARK) + specs->type = integer_type_node; return specs; } Index: gcc/c-parser.c =================================================================== --- gcc/c-parser.c (branch diag-2) +++ gcc/c-parser.c (working copy) @@ -433,6 +433,22 @@ c_parser_next_token_is_keyword (c_parser return c_parser_peek_token (parser)->keyword == keyword; } +/* Return a pointer to the next-but-one token from PARSER, reading it + in if necessary. The next token is already read in. */ + +static c_token * +c_parser_peek_2nd_token (c_parser *parser) +{ + if (parser->tokens_avail >= 2) + return &parser->tokens[1]; + gcc_assert (parser->tokens_avail == 1); + gcc_assert (parser->tokens[0].type != CPP_EOF); + gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL); + c_lex_one_token (parser, &parser->tokens[1]); + parser->tokens_avail = 2; + return &parser->tokens[1]; +} + /* Return true if TOKEN can start a type name, false otherwise. */ static bool @@ -497,13 +513,46 @@ c_token_starts_typename (c_token *token) } } +enum c_lookahead_kind { + /* Always treat unknown identifiers as typenames. */ + cla_prefer_type, + + /* Could be parsing a nonabstract declarator. Only treat an identifier + as a typename if followed by another identifier or a star. */ + cla_nonabstract_decl, + + /* Never treat identifiers as typenames. */ + cla_prefer_id +}; + /* Return true if the next token from PARSER can start a type name, - false otherwise. */ + false otherwise. LA specifies how to do lookahead in order to + detect unknown type names. If unsure, pick CLA_PREFER_ID. */ + static inline bool -c_parser_next_token_starts_typename (c_parser *parser) +c_parser_next_tokens_start_typename (c_parser *parser, enum c_lookahead_kind la) { c_token *token = c_parser_peek_token (parser); - return c_token_starts_typename (token); + if (c_token_starts_typename (token)) + return true; + + /* Try a bit harder to detect an unknown typename. */ + if (la != cla_prefer_id + && token->type == CPP_NAME + && token->id_kind == C_ID_ID + + /* Do not try too hard when we could have "object in array". */ + && !parser->objc_could_be_foreach_context + + && (la == cla_prefer_type + || c_parser_peek_2nd_token (parser)->type == CPP_NAME + || c_parser_peek_2nd_token (parser)->type == CPP_MULT) + + /* Only unknown identifiers. */ + && !lookup_name (token->value)) + return true; + + return false; } /* Return true if TOKEN is a type qualifier, false otherwise. */ @@ -631,8 +680,6 @@ c_token_starts_declaration (c_token *tok return false; } -static c_token *c_parser_peek_2nd_token (c_parser *parser); - /* Return true if the next token from PARSER can start declaration specifiers, false otherwise. */ static inline bool @@ -677,36 +724,12 @@ c_parser_next_tokens_start_declaration ( if (c_token_starts_declaration (token)) return true; - /* Try a bit harder to detect an unknown typename. */ - if (token->type == CPP_NAME - && token->id_kind == C_ID_ID - && (c_parser_peek_2nd_token (parser)->type == CPP_NAME - || c_parser_peek_2nd_token (parser)->type == CPP_MULT) - && !lookup_name (token->value) - - /* Do not try too hard when we could have "object in array". */ - && !parser->objc_could_be_foreach_context) + if (c_parser_next_tokens_start_typename (parser, cla_nonabstract_decl)) return true; return false; } -/* Return a pointer to the next-but-one token from PARSER, reading it - in if necessary. The next token is already read in. */ - -static c_token * -c_parser_peek_2nd_token (c_parser *parser) -{ - if (parser->tokens_avail >= 2) - return &parser->tokens[1]; - gcc_assert (parser->tokens_avail == 1); - gcc_assert (parser->tokens[0].type != CPP_EOF); - gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL); - c_lex_one_token (parser, &parser->tokens[1]); - parser->tokens_avail = 2; - return &parser->tokens[1]; -} - /* Consume the next token from PARSER. */ static void @@ -1076,7 +1099,7 @@ static void c_parser_declaration_or_fnde static void c_parser_static_assert_declaration_no_semi (c_parser *); static void c_parser_static_assert_declaration (c_parser *); static void c_parser_declspecs (c_parser *, struct c_declspecs *, bool, bool, - bool); + bool, enum c_lookahead_kind); static struct c_typespec c_parser_enum_specifier (c_parser *); static struct c_typespec c_parser_struct_or_union_specifier (c_parser *); static tree c_parser_struct_declaration (c_parser *); @@ -1425,7 +1448,8 @@ c_parser_declaration_or_fndef (c_parser fndef_ok = !nested; } - c_parser_declspecs (parser, specs, true, true, start_attr_ok); + c_parser_declspecs (parser, specs, true, true, start_attr_ok, + cla_nonabstract_decl); if (parser->error) { c_parser_skip_to_end_of_block_or_statement (parser); @@ -1922,12 +1945,16 @@ c_parser_static_assert_declaration_no_se static void c_parser_declspecs (c_parser *parser, struct c_declspecs *specs, - bool scspec_ok, bool typespec_ok, bool start_attr_ok) + bool scspec_ok, bool typespec_ok, bool start_attr_ok, + enum c_lookahead_kind la) { bool attrs_ok = start_attr_ok; bool seen_type = specs->typespec_kind != ctsk_none; - while ((c_parser_next_token_is (parser, CPP_NAME) - && c_parser_peek_token (parser)->id_kind != C_ID_ID) + + if (!typespec_ok) + gcc_assert (la == cla_prefer_id); + + while (c_parser_next_token_is (parser, CPP_NAME) || c_parser_next_token_is (parser, CPP_KEYWORD) || (c_dialect_objc () && c_parser_next_token_is (parser, CPP_LESS))) { @@ -1935,21 +1962,14 @@ c_parser_declspecs (c_parser *parser, st tree attrs; location_t loc = c_parser_peek_token (parser)->location; - if (!c_parser_next_token_is_qualifier (parser)) - { - /* Exit for TYPENAMEs after any type because they can appear as a - field name. */ - if (seen_type && c_parser_next_token_is (parser, CPP_NAME)) - break; - - /* If we cannot accept a type, and the next token must start one, - exit. Do the same if we already have seen a tagged definition, - since it would be an error anyway and likely the user has simply - forgotten a semicolon. */ - if ((!typespec_ok || specs->typespec_kind == ctsk_tagdef) - && c_parser_next_token_starts_typename (parser)) - break; - } + /* If we cannot accept a type, exit if the next token must start + one. Also, if we already have seen a tagged definition, + a typename would be an error anyway and likely the user + has simply forgotten a semicolon, so we exit. */ + if ((!typespec_ok || specs->typespec_kind == ctsk_tagdef) + && c_parser_next_tokens_start_typename (parser, la) + && !c_parser_next_token_is_qualifier (parser)) + break; if (c_parser_next_token_is (parser, CPP_NAME)) { @@ -1966,20 +1986,34 @@ c_parser_declspecs (c_parser *parser, st continue; } - /* Now at a C_ID_TYPENAME or C_ID_CLASSNAME. */ + gcc_assert (!c_parser_next_token_is_qualifier (parser)); + + /* If we cannot accept a type, and the next token must start one, + exit. Do the same if we already have seen a tagged definition, + since it would be an error anyway and likely the user has simply + forgotten a semicolon. */ + if (seen_type || !c_parser_next_tokens_start_typename (parser, la)) + break; + + /* Now at an unknown typename (C_ID_ID), a C_ID_TYPENAME or + a C_ID_CLASSNAME. */ c_parser_consume_token (parser); seen_type = true; attrs_ok = true; - if (kind == C_ID_TYPENAME - && (!c_dialect_objc () - || c_parser_next_token_is_not (parser, CPP_LESS))) + if (kind == C_ID_ID) + { + error ("unknown type name %qE", value); + t.kind = ctsk_typedef; + t.spec = error_mark_node; + } + else if (kind == C_ID_TYPENAME + && (!c_dialect_objc () + || c_parser_next_token_is_not (parser, CPP_LESS))) { t.kind = ctsk_typedef; /* For a typedef name, record the meaning, not the name. In case of 'foo foo, bar;'. */ t.spec = lookup_name (value); - t.expr = NULL_TREE; - t.expr_const_operands = true; } else { @@ -1989,9 +2023,9 @@ c_parser_declspecs (c_parser *parser, st if (c_parser_next_token_is (parser, CPP_LESS)) proto = c_parser_objc_protocol_refs (parser); t.spec = objc_get_protocol_qualified_type (value, proto); - t.expr = NULL_TREE; - t.expr_const_operands = true; } + t.expr = NULL_TREE; + t.expr_const_operands = true; declspecs_add_type (loc, specs, t); continue; } @@ -2498,7 +2532,7 @@ c_parser_struct_declaration (c_parser *p } specs = build_null_declspecs (); decl_loc = c_parser_peek_token (parser)->location; - c_parser_declspecs (parser, specs, false, true, true); + c_parser_declspecs (parser, specs, false, true, true, cla_nonabstract_decl); if (parser->error) return NULL_TREE; if (!specs->declspecs_seen_p) @@ -2644,7 +2678,7 @@ c_parser_typeof_specifier (c_parser *par in_typeof--; return ret; } - if (c_parser_next_token_starts_typename (parser)) + if (c_parser_next_tokens_start_typename (parser, cla_prefer_id)) { struct c_type_name *type = c_parser_type_name (parser); c_inhibit_evaluation_warnings--; @@ -2770,7 +2804,8 @@ c_parser_declarator (c_parser *parser, b struct c_declspecs *quals_attrs = build_null_declspecs (); struct c_declarator *inner; c_parser_consume_token (parser); - c_parser_declspecs (parser, quals_attrs, false, false, true); + c_parser_declspecs (parser, quals_attrs, false, false, true, + cla_prefer_id); inner = c_parser_declarator (parser, type_seen_p, kind, seen_id); if (inner == NULL) return NULL; @@ -2922,12 +2956,14 @@ c_parser_direct_declarator_inner (c_pars bool star_seen; tree dimen; c_parser_consume_token (parser); - c_parser_declspecs (parser, quals_attrs, false, false, true); + c_parser_declspecs (parser, quals_attrs, false, false, true, + cla_prefer_id); static_seen = c_parser_next_token_is_keyword (parser, RID_STATIC); if (static_seen) c_parser_consume_token (parser); if (static_seen && !quals_attrs->declspecs_seen_p) - c_parser_declspecs (parser, quals_attrs, false, false, true); + c_parser_declspecs (parser, quals_attrs, false, false, true, + cla_prefer_id); if (!quals_attrs->declspecs_seen_p) quals_attrs = NULL; /* If "static" is present, there must be an array dimension. @@ -3015,7 +3049,13 @@ c_parser_parms_declarator (c_parser *par if (id_list_ok && !attrs && c_parser_next_token_is (parser, CPP_NAME) - && c_parser_peek_token (parser)->id_kind == C_ID_ID) + && c_parser_peek_token (parser)->id_kind == C_ID_ID + + /* Look ahead to detect typos in type names. */ + && c_parser_peek_2nd_token (parser)->type != CPP_NAME + && c_parser_peek_2nd_token (parser)->type != CPP_MULT + && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_PAREN + && c_parser_peek_2nd_token (parser)->type != CPP_OPEN_SQUARE) { tree list = NULL_TREE, *nextp = &list; while (c_parser_next_token_is (parser, CPP_NAME) @@ -3178,9 +3218,7 @@ c_parser_parameter_declaration (c_parser if (parser->error) return NULL; c_parser_set_source_position_from_token (token); - if (token->type == CPP_NAME - && c_parser_peek_2nd_token (parser)->type != CPP_COMMA - && c_parser_peek_2nd_token (parser)->type != CPP_CLOSE_PAREN) + if (c_parser_next_tokens_start_typename (parser, cla_prefer_type)) { error ("unknown type name %qE", token->value); parser->error = true; @@ -3199,7 +3237,7 @@ c_parser_parameter_declaration (c_parser declspecs_add_attrs (specs, attrs); attrs = NULL_TREE; } - c_parser_declspecs (parser, specs, true, true, true); + c_parser_declspecs (parser, specs, true, true, true, cla_nonabstract_decl); finish_declspecs (specs); pending_xref_error (); prefix_attrs = specs->attrs; @@ -3489,14 +3527,17 @@ c_parser_type_name (c_parser *parser) struct c_declarator *declarator; struct c_type_name *ret; bool dummy = false; - c_parser_declspecs (parser, specs, false, true, true); + c_parser_declspecs (parser, specs, false, true, true, cla_prefer_type); if (!specs->declspecs_seen_p) { c_parser_error (parser, "expected specifier-qualifier-list"); return NULL; } - pending_xref_error (); - finish_declspecs (specs); + if (specs->type != error_mark_node) + { + pending_xref_error (); + finish_declspecs (specs); + } declarator = c_parser_declarator (parser, specs->typespec_kind != ctsk_none, C_DTR_ABSTRACT, &dummy); @@ -5624,7 +5665,8 @@ c_parser_cast_expression (c_parser *pars /* If the expression begins with a parenthesized type name, it may be either a cast or a compound literal; we need to see whether the next character is '{' to tell the difference. If not, it is - an unary expression. */ + an unary expression. Full detection of unknown typenames here + would require a 3-token lookahead, or parsing parentheses here. */ if (c_parser_next_token_is (parser, CPP_OPEN_PAREN) && c_token_starts_typename (c_parser_peek_2nd_token (parser))) { @@ -6186,16 +6228,16 @@ c_parser_postfix_expression (c_parser *p } t1 = c_parser_type_name (parser); if (t1 == NULL) - { - expr.value = error_mark_node; - break; - } + parser->error = true; if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>")) + gcc_assert (parser->error); + if (parser->error) { c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL); expr.value = error_mark_node; break; } + { tree type = groktypename (t1, NULL, NULL); tree offsetof_ref; @@ -7427,7 +7469,7 @@ c_parser_objc_type_name (c_parser *parse else break; } - if (c_parser_next_token_starts_typename (parser)) + if (c_parser_next_tokens_start_typename (parser, cla_prefer_type)) type_name = c_parser_type_name (parser); if (type_name) type = groktypename (type_name, NULL, NULL); /* { dg-do compile } */ /* { dg-options "-std=gnu89" } */ static t1 *a; /* { dg-error "unknown type name 't1'" } */ int z; /* { dg-message "previous declaration of 'z'" } */ typedef t2 *z; /* { dg-error "unknown type name 't2'" } */ /* { dg-error "'z' redeclared " "" { target *-*-* } 7 } */ extern t3 p1(void); /* { dg-error "unknown type name 't3'" } */ int p2(const t4 x); /* { dg-error "unknown type name 't4'" } */ int p3(const t1 x); /* { dg-error "unknown type name 't1'" } */ /* dup??? */ int p4(t5 (*x)(void)); /* { dg-error "unknown type name 't5'" } */ int p5(t6 *); /* { dg-error "unknown type name 't6'" } */ int p6(t7 x); /* { dg-error "unknown type name 't7'" } */ int p7(t8[]); /* { dg-error "unknown type name 't8'" } */ int p8(int, t9); /* { dg-error "unknown type name 't9'" } */ struct s { const t1 a; /* { dg-error "unknown type name 't1'" } */ /* dup??? */ const t10 b; /* { dg-error "unknown type name 't10'" } */ int b; /* { dg-error "duplicate member" } */ }; typeof (z) c1; typeof (x1) c2; /* { dg-error "undeclared" } */ typeof (const t11) c3; /* { dg-error "unknown type name 't11'" } */ typeof (t11 *) c3; /* { dg-error "unknown type name 't12'" "" { xfail *-*-* } } */ /* { dg-bogus "unknown type name 'x1'" "" { target *-*-* } 26 } */ /* { dg-bogus "undeclared" "" { xfail *-*-* } 28 } */ /* { dg-bogus "expected expression before" "" { xfail *-*-* } 28 } */ int recover1; int s0 = sizeof (z); int s1 = sizeof (x2); /* { dg-error "undeclared" } */ int s2 = sizeof (const t12); /* { dg-error "unknown type name 't12'" } */ int s3 = sizeof (t13 *); /* { dg-error "unknown type name 't13'" "" { xfail *-*-* } } */ int recover2; /* { dg-bogus "unknown type name 'x2'" "" { target *-*-* } 36 } */ /* { dg-bogus "undeclared" "" { xfail *-*-* } 38 } */ /* { dg-bogus "expected expression before" "" { xfail *-*-* } 38 } */ int a0 = __alignof__ (z); int a1 = __alignof__ (x3); /* { dg-error "undeclared" } */ int a2 = __alignof__ (const t14); /* { dg-error "unknown type name 't14'" } */ int a3 = __alignof__ (t15 *); /* { dg-error "unknown type name 't15'" "" { xfail *-*-* } } */ int recover3; /* { dg-bogus "unknown type name 'x3'" "" { target *-*-* } 47 } */ /* { dg-bogus "undeclared" "" { xfail *-*-* } 49 } */ /* { dg-bogus "expected expression before" "" { xfail *-*-* } 49 } */ /* Cannot detect (undefd_type *) or (undefd_type (*) because it would require 3 tokens of lookahead (same as above). */ const char *f1() { return (const t16) "abc"; /* { dg-error "unknown type name 't16'" } */ /* { dg-bogus "expected" "" { target *-*-* } 63 } */ } const char *f2() { return (const t17 *) "abc"; /* { dg-error "unknown type name 't17'" } */ /* { dg-bogus "expected" "" { target *-*-* } 69 } */ } /* The parser has problems distinguishing semantic and syntactic errors, so it emits a wrong "expected ')'" error here. */ void *f3(int x) { return (void *) ((void *(*)(t18)) f3); /* { dg-error "unknown type name 't18'" } */ /* { dg-bogus "expected" "" { xfail *-*-* } 79 } */ } const void *f4() { return &((const t19){1}); /* { dg-error "unknown type name 't19'" } */ /* { dg-bogus "return discards 'const'" "" { target *-*-* } 85 } */ /* { dg-bogus "expected" "" { target *-*-* } 85 } */ } int f5(__builtin_va_list ap) { int x = __builtin_va_arg (ap, t20); /* { dg-error "unknown type name 't20'" } */ int y = __builtin_va_arg (ap, const t21); /* { dg-error "unknown type name 't21'" } */ } int f6(void) { return __builtin_offsetof (t22, field); /* { dg-error "unknown type name 't22'" } */ /* { dg-bogus "request for member" "" { target *-*-* } 98 } */ }