/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c

Bug Summary

File:	build/gcc/c/c-parser.c
Warning:	line 8062, column 9 Passed-by-value struct argument contains uninitialized data (e.g., via the field chain: 'src_range.m_start')
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name c-parser.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -analyzer-config-compatibility-mode=true -mrelocation-model static -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D IN_GCC_FRONTEND -D IN_GCC -D HAVE_CONFIG_H -I . -I c -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcpp/include -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libcody -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libdecnumber/bid -I ../libdecnumber -I /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/../libbacktrace -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10 -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/x86_64-suse-linux -internal-isystem /usr/bin/../lib64/gcc/x86_64-suse-linux/10/../../../../include/c++/10/backward -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-narrowing -Wwrite-strings -Wno-error=format-diag -Wno-long-long -Wno-variadic-macros -Wno-overlength-strings -fdeprecated-macro -fdebug-compilation-dir /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/gcc -ferror-limit 19 -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=plist-html -analyzer-config silence-checkers=core.NullDereference -faddrsig -o /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/objdir/clang-static-analyzer/2021-01-16-135054-17580-1/report-ZH334c.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c
/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c

→
1/* Parser for C and Objective-C.
 Copyright (C) 1987-2021 Free Software Foundation, Inc.

 Parser actions based on the old Bison parser; structure somewhat
 influenced by and fragments based on the C++ parser.

7This file is part of GCC.

9GCC is free software; you can redistribute it and/or modify it under
10the terms of the GNU General Public License as published by the Free
11Software Foundation; either version 3, or (at your option) any later
12version.

14GCC is distributed in the hope that it will be useful, but WITHOUT ANY
15WARRANTY; without even the implied warranty of MERCHANTABILITY or
16FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
17for more details.

19You should have received a copy of the GNU General Public License
20along with GCC; see the file COPYING3.  If not see
21<http://www.gnu.org/licenses/>.  */

23/* TODO:

 Make sure all relevant comments, and all relevant code from all
 actions, brought over from old parser.  Verify exact correspondence
 of syntax accepted.

 Add testcases covering every input symbol in every state in old and
 new parsers.

 Include full syntax for GNU C, including erroneous cases accepted
 with error messages, in syntax productions in comments.

 Make more diagnostics in the front end generally take an explicit
 location rather than implicitly using input_location.  */

38#include "config.h"
39#define INCLUDE_UNIQUE_PTR
40#include "system.h"
41#include "coretypes.h"
42#include "target.h"
43#include "function.h"
44#include "c-tree.h"
45#include "timevar.h"
46#include "stringpool.h"
47#include "cgraph.h"
48#include "attribs.h"
49#include "stor-layout.h"
50#include "varasm.h"
51#include "trans-mem.h"
52#include "c-family/c-pragma.h"
53#include "c-lang.h"
54#include "c-family/c-objc.h"
55#include "plugin.h"
56#include "omp-general.h"
57#include "omp-offload.h"
58#include "builtins.h"
59#include "gomp-constants.h"
60#include "c-family/c-indentation.h"
61#include "gimple-expr.h"
62#include "context.h"
63#include "gcc-rich-location.h"
64#include "c-parser.h"
65#include "gimple-parser.h"
66#include "read-rtl-function.h"
67#include "run-rtl-passes.h"
68#include "intl.h"
69#include "c-family/name-hint.h"
70#include "tree-iterator.h"
71#include "tree-pretty-print.h"
72#include "memmodel.h"
73#include "c-family/known-headers.h"

75/* We need to walk over decls with incomplete struct/union/enum types
 after parsing the whole translation unit.
 In finish_decl(), if the decl is static, has incomplete
 struct/union/enum type, it is appended to incomplete_record_decls.
 In c_parser_translation_unit(), we iterate over incomplete_record_decls
 and report error if any of the decls are still incomplete.  */ 

82vec<tree> incomplete_record_decls;

84void
85set_c_expr_source_range (c_expr *expr,
	 location_t start, location_t finish)
87{
expr->src_range.m_start = start;
expr->src_range.m_finish = finish;
if (expr->value)
  set_source_range (expr->value, start, finish);
92}

94void
95set_c_expr_source_range (c_expr *expr,
	 source_range src_range)
97{
expr->src_range = src_range;
if (expr->value)
  set_source_range (expr->value, src_range);
101}

103
104/* Initialization routine for this file.  */

106void
107c_parse_init (void)
108{
/* The only initialization required is of the reserved word
   identifiers.  */
unsigned int i;
tree id;
int mask = 0;

/* Make sure RID_MAX hasn't grown past the 8 bits used to hold the keyword in
   the c_token structure.  */
gcc_assert (RID_MAX <= 255)((void)(!(RID_MAX <= 255) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 117, __FUNCTION__), 0 : 0));

mask |= D_CXXONLY0x0002;
if (!flag_isoc99)
  mask |= D_C990x0004;
if (flag_no_asmglobal_options.x_flag_no_asm)
  {
    mask |= D_ASM0x0040 | D_EXT0x0010;
    if (!flag_isoc99)
mask |= D_EXT890x0020;
  }
if (!c_dialect_objc ()((c_language & clk_objc) != 0))
  mask |= D_OBJC0x0080 | D_CXX_OBJC0x0100;

ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX);
for (i = 0; i < num_c_common_reswords; i++)
  {
    /* If a keyword is disabled, do not enter it into the table
and so create a canonical spelling that isn't a keyword.  */
    if (c_common_reswords[i].disable & mask)
{
 if (warn_cxx_compatglobal_options.x_warn_cxx_compat
     && (c_common_reswords[i].disable & D_CXXWARN0x0200))
   {
     id = get_identifier (c_common_reswords[i].word)(__builtin_constant_p (c_common_reswords[i].word) ? get_identifier_with_length
 ((c_common_reswords[i].word), strlen (c_common_reswords[i].word
)) : get_identifier (c_common_reswords[i].word));
     C_SET_RID_CODE (id, RID_CXX_COMPAT_WARN)(((struct c_common_identifier *) (id))->node.rid_code = (unsigned
 char) RID_CXX_COMPAT_WARN);
     C_IS_RESERVED_WORD (id)((tree_not_check2 ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 143, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0) = 1;
   }
 continue;
}

    id = get_identifier (c_common_reswords[i].word)(__builtin_constant_p (c_common_reswords[i].word) ? get_identifier_with_length
 ((c_common_reswords[i].word), strlen (c_common_reswords[i].word
)) : get_identifier (c_common_reswords[i].word));
    C_SET_RID_CODE (id, c_common_reswords[i].rid)(((struct c_common_identifier *) (id))->node.rid_code = (unsigned
 char) c_common_reswords[i].rid);
    C_IS_RESERVED_WORD (id)((tree_not_check2 ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 150, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0) = 1;
    ridpointers [(int) c_common_reswords[i].rid] = id;
  }

for (i = 0; i < NUM_INT_N_ENTS1; i++)
  {
    /* We always create the symbols but they aren't always supported.  */
    char name[50];
    sprintf (name, "__int%d", int_n_data[i].bitsize);
    id = get_identifier (name)(__builtin_constant_p (name) ? get_identifier_with_length ((name
), strlen (name)) : get_identifier (name));
    C_SET_RID_CODE (id, RID_FIRST_INT_N + i)(((struct c_common_identifier *) (id))->node.rid_code = (unsigned
 char) RID_FIRST_INT_N + i);
    C_IS_RESERVED_WORD (id)((tree_not_check2 ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 161, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0) = 1;

    sprintf (name, "__int%d__", int_n_data[i].bitsize);
    id = get_identifier (name)(__builtin_constant_p (name) ? get_identifier_with_length ((name
), strlen (name)) : get_identifier (name));
    C_SET_RID_CODE (id, RID_FIRST_INT_N + i)(((struct c_common_identifier *) (id))->node.rid_code = (unsigned
 char) RID_FIRST_INT_N + i);
    C_IS_RESERVED_WORD (id)((tree_not_check2 ((id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 166, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0) = 1;
  }
168}
169
170/* A parser structure recording information about the state and
 context of parsing.  Includes lexer information with up to two
 tokens of look-ahead; more are not needed for C.  */
173struct GTY(()) c_parser {
/* The look-ahead tokens.  */
c_token * GTY((skip)) tokens;
/* Buffer for look-ahead tokens.  */
c_token tokens_buf[4];
/* How many look-ahead tokens are available (0 - 4, or
   more if parsing from pre-lexed tokens).  */
unsigned int tokens_avail;
/* Raw look-ahead tokens, used only for checking in Objective-C
   whether '[[' starts attributes.  */
vec<c_token, va_gc> *raw_tokens;
/* The number of raw look-ahead tokens that have since been fully
   lexed.  */
unsigned int raw_tokens_used;
/* True if a syntax error is being recovered from; false otherwise.
   c_parser_error sets this flag.  It should clear this flag when
   enough tokens have been consumed to recover from the error.  */
BOOL_BITFIELDunsigned int error : 1;
/* True if we're processing a pragma, and shouldn't automatically
   consume CPP_PRAGMA_EOL.  */
BOOL_BITFIELDunsigned int in_pragma : 1;
/* True if we're parsing the outermost block of an if statement.  */
BOOL_BITFIELDunsigned int in_if_block : 1;
/* True if we want to lex a translated, joined string (for an
   initial #pragma pch_preprocess).  Otherwise the parser is
   responsible for concatenating strings and translating to the
   execution character set as needed.  */
BOOL_BITFIELDunsigned int lex_joined_string : 1;
/* True if, when the parser is concatenating string literals, it
   should translate them to the execution character set (false
   inside attributes).  */
BOOL_BITFIELDunsigned int translate_strings_p : 1;

/* Objective-C specific parser/lexer information.  */

/* True if we are in a context where the Objective-C "PQ" keywords
   are considered keywords.  */
BOOL_BITFIELDunsigned int objc_pq_context : 1;
/* True if we are parsing a (potential) Objective-C foreach
   statement.  This is set to true after we parsed 'for (' and while
   we wait for 'in' or ';' to decide if it's a standard C for loop or an
   Objective-C foreach loop.  */
BOOL_BITFIELDunsigned int objc_could_be_foreach_context : 1;
/* The following flag is needed to contextualize Objective-C lexical
   analysis.  In some cases (e.g., 'int NSObject;'), it is
   undesirable to bind an identifier to an Objective-C class, even
   if a class with that name exists.  */
BOOL_BITFIELDunsigned int objc_need_raw_identifier : 1;
/* Nonzero if we're processing a __transaction statement.  The value
   is 1 | TM_STMT_ATTR_*.  */
unsigned int in_transaction : 4;
/* True if we are in a context where the Objective-C "Property attribute"
   keywords are valid.  */
BOOL_BITFIELDunsigned int objc_property_attr_context : 1;

/* Whether we have just seen/constructed a string-literal.  Set when
   returning a string-literal from c_parser_string_literal.  Reset
   in consume_token.  Useful when we get a parse error and see an
   unknown token, which could have been a string-literal constant
   macro.  */
BOOL_BITFIELDunsigned int seen_string_literal : 1;

/* Location of the last consumed token.  */
location_t last_token_location;
237};

239/* Return a pointer to the Nth token in PARSERs tokens_buf.  */

241c_token *
242c_parser_tokens_buf (c_parser *parser, unsigned n)
243{
return &parser->tokens_buf[n];
245}

247/* Return the error state of PARSER.  */

249bool
250c_parser_error (c_parser *parser)
251{
return parser->error;
253}

255/* Set the error state of PARSER to ERR.  */

257void
258c_parser_set_error (c_parser *parser, bool err)
259{
parser->error = err;
261}


264/* The actual parser and external interface.  ??? Does this need to be
 garbage-collected?  */

267static GTY (()) c_parser *the_parser;

269/* Read in and lex a single token, storing it in *TOKEN.  If RAW,
 context-sensitive postprocessing of the token is not done.  */

272static void
273c_lex_one_token (c_parser *parser, c_token *token, bool raw = false)
274{
timevar_push (TV_LEX);

if (raw || vec_safe_length (parser->raw_tokens) == 0)
  {
    token->type = c_lex_with_flags (&token->value, &token->location,
		      &token->flags,
		      (parser->lex_joined_string
		       ? 0 : C_LEX_STRING_NO_JOIN2));
    token->id_kind = C_ID_NONE;
    token->keyword = RID_MAX;
    token->pragma_kind = PRAGMA_NONE;
  }
else
  {
    /* Use a token previously lexed as a raw look-ahead token, and
complete the processing on it.  */
    *token = (*parser->raw_tokens)[parser->raw_tokens_used];
    ++parser->raw_tokens_used;
    if (parser->raw_tokens_used == vec_safe_length (parser->raw_tokens))
{
 vec_free (parser->raw_tokens);
 parser->raw_tokens_used = 0;
}
  }

if (raw)
  goto out;

switch (token->type)
  {
  case CPP_NAME:
    {
tree decl;

bool objc_force_identifier = parser->objc_need_raw_identifier;
if (c_dialect_objc ()((c_language & clk_objc) != 0))
 parser->objc_need_raw_identifier = false;

if (C_IS_RESERVED_WORD (token->value)((tree_not_check2 ((token->value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 313, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0))
 {
   enum rid rid_code = C_RID_CODE (token->value)((enum rid) (((struct c_common_identifier *) (token->value
))->node.rid_code));

   if (rid_code == RID_CXX_COMPAT_WARN)
     {
warning_at (token->location,
	    OPT_Wc___compat,
	    "identifier %qE conflicts with C++ keyword",
	    token->value);
     }
   else if (rid_code >= RID_FIRST_ADDR_SPACE
     && rid_code <= RID_LAST_ADDR_SPACE)
     {
addr_space_t as;
as = (addr_space_t) (rid_code - RID_FIRST_ADDR_SPACE);
targetm.addr_space.diagnose_usage (as, token->location);
token->id_kind = C_ID_ADDRSPACE;
token->keyword = rid_code;
break;
     }
   else if (c_dialect_objc ()((c_language & clk_objc) != 0) && OBJC_IS_PQ_KEYWORD (rid_code)((unsigned int) (rid_code) >= (unsigned int) RID_FIRST_PQ &&
 (unsigned int) (rid_code) <= (unsigned int) RID_LAST_PQ))
     {
/* We found an Objective-C "pq" keyword (in, out,
   inout, bycopy, byref, oneway).  They need special
   care because the interpretation depends on the
   context.  */
if (parser->objc_pq_context)
  {
    token->type = CPP_KEYWORD;
    token->keyword = rid_code;
    break;
  }
else if (parser->objc_could_be_foreach_context
	 && rid_code == RID_IN)
  {
    /* We are in Objective-C, inside a (potential)
       foreach context (which means after having
       parsed 'for (', but before having parsed ';'),
       and we found 'in'.  We consider it the keyword
       which terminates the declaration at the
       beginning of a foreach-statement.  Note that
       this means you can't use 'in' for anything else
       in that context; in particular, in Objective-C
       you can't use 'in' as the name of the running
       variable in a C for loop.  We could potentially
       try to add code here to disambiguate, but it
       seems a reasonable limitation.  */
    token->type = CPP_KEYWORD;
    token->keyword = rid_code;
    break;
  }
/* Else, "pq" keywords outside of the "pq" context are
   not keywords, and we fall through to the code for
   normal tokens.  */
     }
   else if (c_dialect_objc ()((c_language & clk_objc) != 0) && OBJC_IS_PATTR_KEYWORD (rid_code)((((unsigned int) (rid_code) >= (unsigned int) RID_FIRST_PATTR
 && (unsigned int) (rid_code) <= (unsigned int) RID_LAST_PATTR
)) || rid_code == RID_CLASS))
     {
/* We found an Objective-C "property attribute"
   keyword (getter, setter, readonly, etc). These are
   only valid in the property context.  */
if (parser->objc_property_attr_context)
  {
    token->type = CPP_KEYWORD;
    token->keyword = rid_code;
    break;
  }
/* Else they are not special keywords.
*/
     }
   else if (c_dialect_objc ()((c_language & clk_objc) != 0) 
     && (OBJC_IS_AT_KEYWORD (rid_code)((unsigned int) (rid_code) >= (unsigned int) RID_FIRST_AT &&
 (unsigned int) (rid_code) <= (unsigned int) RID_LAST_AT)
	 || OBJC_IS_CXX_KEYWORD (rid_code)(rid_code == RID_CLASS || rid_code == RID_SYNCHRONIZED || rid_code
 == RID_PUBLIC || rid_code == RID_PROTECTED || rid_code == RID_PRIVATE
 || rid_code == RID_TRY || rid_code == RID_THROW || rid_code ==
 RID_CATCH)))
     {
/* We found one of the Objective-C "@" keywords (defs,
   selector, synchronized, etc) or one of the
   Objective-C "cxx" keywords (class, private,
   protected, public, try, catch, throw) without a
   preceding '@' sign.  Do nothing and fall through to
   the code for normal tokens (in C++ we would still
   consider the CXX ones keywords, but not in C).  */
;
     }
   else
     {
token->type = CPP_KEYWORD;
token->keyword = rid_code;
break;
     }
 }

decl = lookup_name (token->value);
if (decl)
 {
   if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL)
     {
token->id_kind = C_ID_TYPENAME;
break;
     }
 }
else if (c_dialect_objc ()((c_language & clk_objc) != 0))
 {
   tree objc_interface_decl = objc_is_class_name (token->value);
   /* Objective-C class names are in the same namespace as
      variables and typedefs, and hence are shadowed by local
      declarations.  */
   if (objc_interface_decl
              && (!objc_force_identifier || global_bindings_p ()))
     {
token->value = objc_interface_decl;
token->id_kind = C_ID_CLASSNAME;
break;
     }
 }
      token->id_kind = C_ID_ID;
    }
    break;
  case CPP_AT_NAME:
    /* This only happens in Objective-C; it must be a keyword.  */
    token->type = CPP_KEYWORD;
    switch (C_RID_CODE (token->value)((enum rid) (((struct c_common_identifier *) (token->value
))->node.rid_code)))
{
 /* Replace 'class' with '@class', 'private' with '@private',
    etc.  This prevents confusion with the C++ keyword
    'class', and makes the tokens consistent with other
    Objective-C 'AT' keywords.  For example '@class' is
    reported as RID_AT_CLASS which is consistent with
    '@synchronized', which is reported as
    RID_AT_SYNCHRONIZED.
 */
case RID_CLASS:     token->keyword = RID_AT_CLASS; break;
case RID_PRIVATE:   token->keyword = RID_AT_PRIVATE; break;
case RID_PROTECTED: token->keyword = RID_AT_PROTECTED; break;
case RID_PUBLIC:    token->keyword = RID_AT_PUBLIC; break;
case RID_THROW:     token->keyword = RID_AT_THROW; break;
case RID_TRY:       token->keyword = RID_AT_TRY; break;
case RID_CATCH:     token->keyword = RID_AT_CATCH; break;
case RID_SYNCHRONIZED: token->keyword = RID_AT_SYNCHRONIZED; break;
default:            token->keyword = C_RID_CODE (token->value)((enum rid) (((struct c_common_identifier *) (token->value
))->node.rid_code));
}
    break;
  case CPP_COLON:
  case CPP_COMMA:
  case CPP_CLOSE_PAREN:
  case CPP_SEMICOLON:
    /* These tokens may affect the interpretation of any identifiers
following, if doing Objective-C.  */
    if (c_dialect_objc ()((c_language & clk_objc) != 0))
parser->objc_need_raw_identifier = false;
    break;
  case CPP_PRAGMA:
    /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
    token->pragma_kind = (enum pragma_kind) TREE_INT_CST_LOW (token->value)((unsigned long) (*tree_int_cst_elt_check ((token->value),
 (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 465, __FUNCTION__)));
    token->value = NULL__null;
    break;
  default:
    break;
  }
out:
timevar_pop (TV_LEX);
473}

475/* Return a pointer to the next token from PARSER, reading it in if
 necessary.  */

478c_token *
479c_parser_peek_token (c_parser *parser)
480{
if (parser->tokens_avail == 0)
  {
    c_lex_one_token (parser, &parser->tokens[0]);
    parser->tokens_avail = 1;
  }
return &parser->tokens[0];
487}

489/* Return a pointer to the next-but-one token from PARSER, reading it
 in if necessary.  The next token is already read in.  */

492c_token *
493c_parser_peek_2nd_token (c_parser *parser)
494{
if (parser->tokens_avail >= 2)
  return &parser->tokens[1];
gcc_assert (parser->tokens_avail == 1)((void)(!(parser->tokens_avail == 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 497, __FUNCTION__), 0 : 0));
gcc_assert (parser->tokens[0].type != CPP_EOF)((void)(!(parser->tokens[0].type != CPP_EOF) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 498, __FUNCTION__), 0 : 0));
gcc_assert (parser->tokens[0].type != CPP_PRAGMA_EOL)((void)(!(parser->tokens[0].type != CPP_PRAGMA_EOL) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 499, __FUNCTION__), 0 : 0));
c_lex_one_token (parser, &parser->tokens[1]);
parser->tokens_avail = 2;
return &parser->tokens[1];
503}

505/* Return a pointer to the Nth token from PARSER, reading it
 in if necessary.  The N-1th token is already read in.  */

508c_token *
509c_parser_peek_nth_token (c_parser *parser, unsigned int n)
510{
/* N is 1-based, not zero-based.  */
gcc_assert (n > 0)((void)(!(n > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 512, __FUNCTION__), 0 : 0));

if (parser->tokens_avail >= n)
  return &parser->tokens[n - 1];
gcc_assert (parser->tokens_avail == n - 1)((void)(!(parser->tokens_avail == n - 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 516, __FUNCTION__), 0 : 0));
c_lex_one_token (parser, &parser->tokens[n - 1]);
parser->tokens_avail = n;
return &parser->tokens[n - 1];
520}

522/* Return a pointer to the Nth token from PARSER, reading it in as a
 raw look-ahead token if necessary.  The N-1th token is already read
 in.  Raw look-ahead tokens remain available for when the non-raw
 functions above are called.  */

527c_token *
528c_parser_peek_nth_token_raw (c_parser *parser, unsigned int n)
529{
/* N is 1-based, not zero-based.  */
gcc_assert (n > 0)((void)(!(n > 0) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 531, __FUNCTION__), 0 : 0));

if (parser->tokens_avail >= n)
  return &parser->tokens[n - 1];
unsigned int raw_len = vec_safe_length (parser->raw_tokens);
unsigned int raw_avail
  = parser->tokens_avail + raw_len - parser->raw_tokens_used;
gcc_assert (raw_avail >= n - 1)((void)(!(raw_avail >= n - 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 538, __FUNCTION__), 0 : 0));
if (raw_avail >= n)
  return &(*parser->raw_tokens)[parser->raw_tokens_used
		  + n - 1 - parser->tokens_avail];
vec_safe_reserve (parser->raw_tokens, 1);
parser->raw_tokens->quick_grow (raw_len + 1);
c_lex_one_token (parser, &(*parser->raw_tokens)[raw_len], true);
return &(*parser->raw_tokens)[raw_len];
546}

548bool
549c_keyword_starts_typename (enum rid keyword)
550{
switch (keyword)
  {
  case RID_UNSIGNED:
  case RID_LONG:
  case RID_SHORT:
  case RID_SIGNED:
  case RID_COMPLEX:
  case RID_INT:
  case RID_CHAR:
  case RID_FLOAT:
  case RID_DOUBLE:
  case RID_VOID:
  case RID_DFLOAT32:
  case RID_DFLOAT64:
  case RID_DFLOAT128:
  CASE_RID_FLOATN_NXcase RID_FLOAT16: case RID_FLOAT32: case RID_FLOAT64: case RID_FLOAT128
: case RID_FLOAT32X: case RID_FLOAT64X: case RID_FLOAT128X:
  case RID_BOOL:
  case RID_ENUM:
  case RID_STRUCT:
  case RID_UNION:
  case RID_TYPEOF:
  case RID_CONST:
  case RID_ATOMIC:
  case RID_VOLATILE:
  case RID_RESTRICT:
  case RID_ATTRIBUTE:
  case RID_FRACT:
  case RID_ACCUM:
  case RID_SAT:
  case RID_AUTO_TYPE:
  case RID_ALIGNAS:
    return true;
  default:
    if (keyword >= RID_FIRST_INT_N
 && keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS1
 && int_n_enabled_p[keyword - RID_FIRST_INT_N])
return true;
    return false;
  }
590}

592/* Return true if TOKEN can start a type name,
 false otherwise.  */
594bool
595c_token_starts_typename (c_token *token)
596{
switch (token->type)
27
←
Control jumps to 'case CPP_LESS:'  at line 616→
  {
  case CPP_NAME:
    switch (token->id_kind)
{
case C_ID_ID:
 return false;
case C_ID_ADDRSPACE:
 return true;
case C_ID_TYPENAME:
 return true;
case C_ID_CLASSNAME:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 609, __FUNCTION__), 0 : 0));
 return true;
default:
 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 612, __FUNCTION__));
}
  case CPP_KEYWORD:
    return c_keyword_starts_typename (token->keyword);
  case CPP_LESS:
    if (c_dialect_objc ()((c_language & clk_objc) != 0))
28
←
Assuming the condition is true→
29
←
Taking true branch→
return true;
30
←
Returning the value 1, which participates in a condition later→
    return false;
  default:
    return false;
  }
623}

625/* Return true if the next token from PARSER can start a type name,
 false otherwise.  LA specifies how to do lookahead in order to
 detect unknown type names.  If unsure, pick CLA_PREFER_ID.  */

629static inline bool
630c_parser_next_tokens_start_typename (c_parser *parser, enum c_lookahead_kind la)
631{
c_token *token = c_parser_peek_token (parser);
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;
653}

655/* Return true if TOKEN is a type qualifier, false otherwise.  */
656static bool
657c_token_is_qualifier (c_token *token)
658{
switch (token->type)
  {
  case CPP_NAME:
    switch (token->id_kind)
{
case C_ID_ADDRSPACE:
 return true;
default:
 return false;
}
  case CPP_KEYWORD:
    switch (token->keyword)
{
case RID_CONST:
case RID_VOLATILE:
case RID_RESTRICT:
case RID_ATTRIBUTE:
case RID_ATOMIC:
 return true;
default:
 return false;
}
  case CPP_LESS:
    return false;
  default:
    gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 684, __FUNCTION__));
  }
686}

688/* Return true if the next token from PARSER is a type qualifier,
 false otherwise.  */
690static inline bool
691c_parser_next_token_is_qualifier (c_parser *parser)
692{
c_token *token = c_parser_peek_token (parser);
return c_token_is_qualifier (token);
695}

697/* Return true if TOKEN can start declaration specifiers (not
 including standard attributes), false otherwise.  */
699static bool
700c_token_starts_declspecs (c_token *token)
701{
switch (token->type)
  {
  case CPP_NAME:
    switch (token->id_kind)
{
case C_ID_ID:
 return false;
case C_ID_ADDRSPACE:
 return true;
case C_ID_TYPENAME:
 return true;
case C_ID_CLASSNAME:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 714, __FUNCTION__), 0 : 0));
 return true;
default:
 gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 717, __FUNCTION__));
}
  case CPP_KEYWORD:
    switch (token->keyword)
{
case RID_STATIC:
case RID_EXTERN:
case RID_REGISTER:
case RID_TYPEDEF:
case RID_INLINE:
case RID_NORETURN:
case RID_AUTO:
case RID_THREAD:
case RID_UNSIGNED:
case RID_LONG:
case RID_SHORT:
case RID_SIGNED:
case RID_COMPLEX:
case RID_INT:
case RID_CHAR:
case RID_FLOAT:
case RID_DOUBLE:
case RID_VOID:
case RID_DFLOAT32:
case RID_DFLOAT64:
case RID_DFLOAT128:
CASE_RID_FLOATN_NXcase RID_FLOAT16: case RID_FLOAT32: case RID_FLOAT64: case RID_FLOAT128
: case RID_FLOAT32X: case RID_FLOAT64X: case RID_FLOAT128X:
case RID_BOOL:
case RID_ENUM:
case RID_STRUCT:
case RID_UNION:
case RID_TYPEOF:
case RID_CONST:
case RID_VOLATILE:
case RID_RESTRICT:
case RID_ATTRIBUTE:
case RID_FRACT:
case RID_ACCUM:
case RID_SAT:
case RID_ALIGNAS:
case RID_ATOMIC:
case RID_AUTO_TYPE:
 return true;
default:
 if (token->keyword >= RID_FIRST_INT_N
     && token->keyword < RID_FIRST_INT_N + NUM_INT_N_ENTS1
     && int_n_enabled_p[token->keyword - RID_FIRST_INT_N])
   return true;
 return false;
}
  case CPP_LESS:
    if (c_dialect_objc ()((c_language & clk_objc) != 0))
return true;
    return false;
  default:
    return false;
  }
774}


777/* Return true if TOKEN can start declaration specifiers (not
 including standard attributes) or a static assertion, false
 otherwise.  */
780static bool
781c_token_starts_declaration (c_token *token)
782{
if (c_token_starts_declspecs (token)
    || token->keyword == RID_STATIC_ASSERT)
  return true;
else
  return false;
788}

790/* Return true if the next token from PARSER can start declaration
 specifiers (not including standard attributes), false
 otherwise.  */
793bool
794c_parser_next_token_starts_declspecs (c_parser *parser)
795{
c_token *token = c_parser_peek_token (parser);

/* In Objective-C, a classname normally starts a declspecs unless it
   is immediately followed by a dot.  In that case, it is the
   Objective-C 2.0 "dot-syntax" for class objects, ie, calls the
   setter/getter on the class.  c_token_starts_declspecs() can't
   differentiate between the two cases because it only checks the
   current token, so we have a special check here.  */
if (c_dialect_objc ()((c_language & clk_objc) != 0) 
    && token->type == CPP_NAME
    && token->id_kind == C_ID_CLASSNAME 
    && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
  return false;

return c_token_starts_declspecs (token);
811}

813/* Return true if the next tokens from PARSER can start declaration
 specifiers (not including standard attributes) or a static
 assertion, false otherwise.  */
816bool
817c_parser_next_tokens_start_declaration (c_parser *parser)
818{
c_token *token = c_parser_peek_token (parser);

/* Same as above.  */
if (c_dialect_objc ()((c_language & clk_objc) != 0) 
    && token->type == CPP_NAME
    && token->id_kind == C_ID_CLASSNAME 
    && c_parser_peek_2nd_token (parser)->type == CPP_DOT)
  return false;

/* Labels do not start declarations.  */
if (token->type == CPP_NAME
    && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
  return false;

if (c_token_starts_declaration (token))
  return true;

if (c_parser_next_tokens_start_typename (parser, cla_nonabstract_decl))
  return true;

return false;
840}

842/* Consume the next token from PARSER.  */

844void
845c_parser_consume_token (c_parser *parser)
846{
gcc_assert (parser->tokens_avail >= 1)((void)(!(parser->tokens_avail >= 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 847, __FUNCTION__), 0 : 0));
gcc_assert (parser->tokens[0].type != CPP_EOF)((void)(!(parser->tokens[0].type != CPP_EOF) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 848, __FUNCTION__), 0 : 0));
gcc_assert (!parser->in_pragma || parser->tokens[0].type != CPP_PRAGMA_EOL)((void)(!(!parser->in_pragma || parser->tokens[0].type !=
 CPP_PRAGMA_EOL) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 849, __FUNCTION__), 0 : 0));
gcc_assert (parser->error || parser->tokens[0].type != CPP_PRAGMA)((void)(!(parser->error || parser->tokens[0].type != CPP_PRAGMA
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 850, __FUNCTION__), 0 : 0));
parser->last_token_location = parser->tokens[0].location;
if (parser->tokens != &parser->tokens_buf[0])
  parser->tokens++;
else if (parser->tokens_avail >= 2)
  {
    parser->tokens[0] = parser->tokens[1];
    if (parser->tokens_avail >= 3)
      {
        parser->tokens[1] = parser->tokens[2];
        if (parser->tokens_avail >= 4)
          parser->tokens[2] = parser->tokens[3];
      }
  }
parser->tokens_avail--;
parser->seen_string_literal = false;
866}

868/* Expect the current token to be a #pragma.  Consume it and remember
 that we've begun parsing a pragma.  */

871static void
872c_parser_consume_pragma (c_parser *parser)
873{
gcc_assert (!parser->in_pragma)((void)(!(!parser->in_pragma) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 874, __FUNCTION__), 0 : 0));
gcc_assert (parser->tokens_avail >= 1)((void)(!(parser->tokens_avail >= 1) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 875, __FUNCTION__), 0 : 0));
gcc_assert (parser->tokens[0].type == CPP_PRAGMA)((void)(!(parser->tokens[0].type == CPP_PRAGMA) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 876, __FUNCTION__), 0 : 0));
if (parser->tokens != &parser->tokens_buf[0])
  parser->tokens++;
else if (parser->tokens_avail >= 2)
  {
    parser->tokens[0] = parser->tokens[1];
    if (parser->tokens_avail >= 3)
parser->tokens[1] = parser->tokens[2];
  }
parser->tokens_avail--;
parser->in_pragma = true;
887}

889/* Update the global input_location from TOKEN.  */
890static inline void
891c_parser_set_source_position_from_token (c_token *token)
892{
if (token->type != CPP_EOF)
  {
    input_location = token->location;
  }
897}

899/* Helper function for c_parser_error.
 Having peeked a token of kind TOK1_KIND that might signify
 a conflict marker, peek successor tokens to determine
 if we actually do have a conflict marker.
 Specifically, we consider a run of 7 '<', '=' or '>' characters
 at the start of a line as a conflict marker.
 These come through the lexer as three pairs and a single,
 e.g. three CPP_LSHIFT ("<<") and a CPP_LESS ('<').
 If it returns true, *OUT_LOC is written to with the location/range
 of the marker.  */

910static bool
911c_parser_peek_conflict_marker (c_parser *parser, enum cpp_ttype tok1_kind,
	       location_t *out_loc)
913{
c_token *token2 = c_parser_peek_2nd_token (parser);
if (token2->type != tok1_kind)
  return false;
c_token *token3 = c_parser_peek_nth_token (parser, 3);
if (token3->type != tok1_kind)
  return false;
c_token *token4 = c_parser_peek_nth_token (parser, 4);
if (token4->type != conflict_marker_get_final_tok_kind (tok1_kind))
  return false;

/* It must be at the start of the line.  */
location_t start_loc = c_parser_peek_token (parser)->location;
if (LOCATION_COLUMN (start_loc)((expand_location (start_loc)).column) != 1)
  return false;

/* We have a conflict marker.  Construct a location of the form:
     <<<<<<<
     ^~~~~~~
   with start == caret, finishing at the end of the marker.  */
location_t finish_loc = get_finish (token4->location);
*out_loc = make_location (start_loc, start_loc, finish_loc);

return true;
937}

939/* Issue a diagnostic of the form
    FILE:LINE: MESSAGE before TOKEN
 where TOKEN is the next token in the input stream of PARSER.
 MESSAGE (specified by the caller) is usually of the form "expected
 OTHER-TOKEN".

 Use RICHLOC as the location of the diagnostic.

 Do not issue a diagnostic if still recovering from an error.

 Return true iff an error was actually emitted.

 ??? This is taken from the C++ parser, but building up messages in
 this way is not i18n-friendly and some other approach should be
 used.  */

955static bool
956c_parser_error_richloc (c_parser *parser, const char *gmsgid,
	rich_location *richloc)
958{
c_token *token = c_parser_peek_token (parser);
if (parser->error)
  return false;
parser->error = true;
if (!gmsgid)
  return false;

/* If this is actually a conflict marker, report it as such.  */
if (token->type == CPP_LSHIFT
    || token->type == CPP_RSHIFT
    || token->type == CPP_EQ_EQ)
  {
    location_t loc;
    if (c_parser_peek_conflict_marker (parser, token->type, &loc))
{
 error_at (loc, "version control conflict marker in file");
 return true;
}
  }

/* If we were parsing a string-literal and there is an unknown name
   token right after, then check to see if that could also have been
   a literal string by checking the name against a list of known
   standard string literal constants defined in header files. If
   there is one, then add that as an hint to the error message. */
auto_diagnostic_group d;
name_hint h;
if (parser->seen_string_literal && token->type == CPP_NAME)
  {
    tree name = token->value;
    const char *token_name = IDENTIFIER_POINTER (name)((const char *) (tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 989, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
    const char *header_hint
= get_c_stdlib_header_for_string_macro_name (token_name);
    if (header_hint != NULL__null)
h = name_hint (NULL__null, new suggest_missing_header (token->location,
					 token_name,
					 header_hint));
  }

c_parse_error (gmsgid,
 /* Because c_parse_error does not understand
    CPP_KEYWORD, keywords are treated like
    identifiers.  */
 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
 /* ??? The C parser does not save the cpp flags of a
    token, we need to pass 0 here and we will not get
    the source spelling of some tokens but rather the
    canonical spelling.  */
 token->value, /*flags=*/0, richloc);
return true;
1009}

1011/* As c_parser_error_richloc, but issue the message at the
 location of PARSER's next token, or at input_location
 if the next token is EOF.  */

1015bool
1016c_parser_error (c_parser *parser, const char *gmsgid)
1017{
c_token *token = c_parser_peek_token (parser);
c_parser_set_source_position_from_token (token);
rich_location richloc (line_table, input_location);
return c_parser_error_richloc (parser, gmsgid, &richloc);
1022}

1024/* Some tokens naturally come in pairs e.g.'(' and ')'.
 This class is for tracking such a matching pair of symbols.
 In particular, it tracks the location of the first token,
 so that if the second token is missing, we can highlight the
 location of the first token when notifying the user about the
 problem.  */

1031template <typename traits_t>
1032class token_pair
1033{
public:
/* token_pair's ctor.  */
token_pair () : m_open_loc (UNKNOWN_LOCATION((location_t) 0)) {}

/* If the next token is the opening symbol for this pair, consume it and
   return true.
   Otherwise, issue an error and return false.
   In either case, record the location of the opening token.  */

bool require_open (c_parser *parser)
{
  c_token *token = c_parser_peek_token (parser);
  if (token)
    m_open_loc = token->location;

  return c_parser_require (parser, traits_t::open_token_type,
	     traits_t::open_gmsgid);
}

/* Consume the next token from PARSER, recording its location as
   that of the opening token within the pair.  */

void consume_open (c_parser *parser)
{
  c_token *token = c_parser_peek_token (parser);
  gcc_assert (token->type == traits_t::open_token_type)((void)(!(token->type == traits_t::open_token_type) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1059, __FUNCTION__), 0 : 0));
  m_open_loc = token->location;
  c_parser_consume_token (parser);
}

/* If the next token is the closing symbol for this pair, consume it
   and return true.
   Otherwise, issue an error, highlighting the location of the
   corresponding opening token, and return false.  */

bool require_close (c_parser *parser) const
{
  return c_parser_require (parser, traits_t::close_token_type,
	     traits_t::close_gmsgid, m_open_loc);
}

/* Like token_pair::require_close, except that tokens will be skipped
   until the desired token is found.  An error message is still produced
   if the next token is not as expected.  */

void skip_until_found_close (c_parser *parser) const
{
  c_parser_skip_until_found (parser, traits_t::close_token_type,
	       traits_t::close_gmsgid, m_open_loc);
}

private:
location_t m_open_loc;
1087};

1089/* Traits for token_pair<T> for tracking matching pairs of parentheses.  */

1091struct matching_paren_traits
1092{
static const enum cpp_ttype open_token_type = CPP_OPEN_PAREN;
static const char * const open_gmsgid;
static const enum cpp_ttype close_token_type = CPP_CLOSE_PAREN;
static const char * const close_gmsgid;
1097};

1099const char * const matching_paren_traits::open_gmsgid = "expected %<(%>";
1100const char * const matching_paren_traits::close_gmsgid = "expected %<)%>";

1102/* "matching_parens" is a token_pair<T> class for tracking matching
 pairs of parentheses.  */

1105typedef token_pair<matching_paren_traits> matching_parens;

1107/* Traits for token_pair<T> for tracking matching pairs of braces.  */

1109struct matching_brace_traits
1110{
static const enum cpp_ttype open_token_type = CPP_OPEN_BRACE;
static const char * const open_gmsgid;
static const enum cpp_ttype close_token_type = CPP_CLOSE_BRACE;
static const char * const close_gmsgid;
1115};

1117const char * const matching_brace_traits::open_gmsgid = "expected %<{%>";
1118const char * const matching_brace_traits::close_gmsgid = "expected %<}%>";

1120/* "matching_braces" is a token_pair<T> class for tracking matching
 pairs of braces.  */

1123typedef token_pair<matching_brace_traits> matching_braces;

1125/* Get a description of the matching symbol to TYPE e.g. "(" for
 CPP_CLOSE_PAREN.  */

1128static const char *
1129get_matching_symbol (enum cpp_ttype type)
1130{
switch (type)
  {
  default:
    gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1134, __FUNCTION__));
    return "";
  case CPP_CLOSE_PAREN:
    return "(";
  case CPP_CLOSE_BRACE:
    return "{";
  }
1141}

1143/* If the next token is of the indicated TYPE, consume it.  Otherwise,
 issue the error MSGID.  If MSGID is NULL then a message has already
 been produced and no message will be produced this time.  Returns
 true if found, false otherwise.

 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
 within any error as the location of an "opening" token matching
 the close token TYPE (e.g. the location of the '(' when TYPE is
 CPP_CLOSE_PAREN).

 If TYPE_IS_UNIQUE is true (the default) then msgid describes exactly
 one type (e.g. "expected %<)%>") and thus it may be reasonable to
 attempt to generate a fix-it hint for the problem.
 Otherwise msgid describes multiple token types (e.g.
 "expected %<;%>, %<,%> or %<)%>"), and thus we shouldn't attempt to
 generate a fix-it hint.  */

1160bool
1161c_parser_require (c_parser *parser,
  enum cpp_ttype type,
  const char *msgid,
  location_t matching_location,
  bool type_is_unique)
1166{
if (c_parser_next_token_is (parser, type))
  {
    c_parser_consume_token (parser);
    return true;
  }
else
  {
    location_t next_token_loc = c_parser_peek_token (parser)->location;
    gcc_rich_location richloc (next_token_loc);

    /* Potentially supply a fix-it hint, suggesting to add the
missing token immediately after the *previous* token.
This may move the primary location within richloc.  */
    if (!parser->error && type_is_unique)
maybe_suggest_missing_token_insertion (&richloc, type,
			       parser->last_token_location);

    /* If matching_location != UNKNOWN_LOCATION, highlight it.
Attempt to consolidate diagnostics by printing it as a
secondary range within the main diagnostic.  */
    bool added_matching_location = false;
    if (matching_location != UNKNOWN_LOCATION((location_t) 0))
added_matching_location
 = richloc.add_location_if_nearby (matching_location);

    if (c_parser_error_richloc (parser, msgid, &richloc))
/* If we weren't able to consolidate matching_location, then
  print it as a secondary diagnostic.  */
if (matching_location != UNKNOWN_LOCATION((location_t) 0) && !added_matching_location)
 inform (matching_location, "to match this %qs",
  get_matching_symbol (type));

    return false;
  }
1201}

1203/* If the next token is the indicated keyword, consume it.  Otherwise,
 issue the error MSGID.  Returns true if found, false otherwise.  */

1206static bool
1207c_parser_require_keyword (c_parser *parser,
	  enum rid keyword,
	  const char *msgid)
1210{
if (c_parser_next_token_is_keyword (parser, keyword))
  {
    c_parser_consume_token (parser);
    return true;
  }
else
  {
    c_parser_error (parser, msgid);
    return false;
  }
1221}

1223/* Like c_parser_require, except that tokens will be skipped until the
 desired token is found.  An error message is still produced if the
 next token is not as expected.  If MSGID is NULL then a message has
 already been produced and no message will be produced this
 time.

 If MATCHING_LOCATION is not UNKNOWN_LOCATION, then highlight it
 within any error as the location of an "opening" token matching
 the close token TYPE (e.g. the location of the '(' when TYPE is
 CPP_CLOSE_PAREN).  */

1234void
1235c_parser_skip_until_found (c_parser *parser,
	   enum cpp_ttype type,
	   const char *msgid,
	   location_t matching_location)
1239{
unsigned nesting_depth = 0;

if (c_parser_require (parser, type, msgid, matching_location))
  return;

/* Skip tokens until the desired token is found.  */
while (true)
  {
    /* Peek at the next token.  */
    c_token *token = c_parser_peek_token (parser);
    /* If we've reached the token we want, consume it and stop.  */
    if (token->type == type && !nesting_depth)
{
 c_parser_consume_token (parser);
 break;
}

    /* If we've run out of tokens, stop.  */
    if (token->type == CPP_EOF)
return;
    if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
return;
    if (token->type == CPP_OPEN_BRACE
 || token->type == CPP_OPEN_PAREN
 || token->type == CPP_OPEN_SQUARE)
++nesting_depth;
    else if (token->type == CPP_CLOSE_BRACE
      || token->type == CPP_CLOSE_PAREN
      || token->type == CPP_CLOSE_SQUARE)
{
 if (nesting_depth-- == 0)
   break;
}
    /* Consume this token.  */
    c_parser_consume_token (parser);
  }
parser->error = false;
1277}

1279/* Skip tokens until the end of a parameter is found, but do not
 consume the comma, semicolon or closing delimiter.  */

1282static void
1283c_parser_skip_to_end_of_parameter (c_parser *parser)
1284{
unsigned nesting_depth = 0;

while (true)
  {
    c_token *token = c_parser_peek_token (parser);
    if ((token->type == CPP_COMMA || token->type == CPP_SEMICOLON)
 && !nesting_depth)
break;
    /* If we've run out of tokens, stop.  */
    if (token->type == CPP_EOF)
return;
    if (token->type == CPP_PRAGMA_EOL && parser->in_pragma)
return;
    if (token->type == CPP_OPEN_BRACE
 || token->type == CPP_OPEN_PAREN
 || token->type == CPP_OPEN_SQUARE)
++nesting_depth;
    else if (token->type == CPP_CLOSE_BRACE
      || token->type == CPP_CLOSE_PAREN
      || token->type == CPP_CLOSE_SQUARE)
{
 if (nesting_depth-- == 0)
   break;
}
    /* Consume this token.  */
    c_parser_consume_token (parser);
  }
parser->error = false;
1313}

1315/* Expect to be at the end of the pragma directive and consume an
 end of line marker.  */

1318static void
1319c_parser_skip_to_pragma_eol (c_parser *parser, bool error_if_not_eol = true)
1320{
gcc_assert (parser->in_pragma)((void)(!(parser->in_pragma) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1321, __FUNCTION__), 0 : 0));
parser->in_pragma = false;

if (error_if_not_eol && c_parser_peek_token (parser)->type != CPP_PRAGMA_EOL)
  c_parser_error (parser, "expected end of line");

cpp_ttype token_type;
do
  {
    c_token *token = c_parser_peek_token (parser);
    token_type = token->type;
    if (token_type == CPP_EOF)
break;
    c_parser_consume_token (parser);
  }
while (token_type != CPP_PRAGMA_EOL);

parser->error = false;
1339}

1341/* Skip tokens until we have consumed an entire block, or until we
 have consumed a non-nested ';'.  */

1344static void
1345c_parser_skip_to_end_of_block_or_statement (c_parser *parser)
1346{
unsigned nesting_depth = 0;
bool save_error = parser->error;

while (true)
  {
    c_token *token;

    /* Peek at the next token.  */
    token = c_parser_peek_token (parser);

    switch (token->type)
{
case CPP_EOF:
 return;

case CPP_PRAGMA_EOL:
 if (parser->in_pragma)
   return;
 break;

case CPP_SEMICOLON:
 /* If the next token is a ';', we have reached the
    end of the statement.  */
 if (!nesting_depth)
   {
     /* Consume the ';'.  */
     c_parser_consume_token (parser);
     goto finished;
   }
 break;

case CPP_CLOSE_BRACE:
 /* If the next token is a non-nested '}', then we have
    reached the end of the current block.  */
 if (nesting_depth == 0 || --nesting_depth == 0)
   {
     c_parser_consume_token (parser);
     goto finished;
   }
 break;

case CPP_OPEN_BRACE:
 /* If it the next token is a '{', then we are entering a new
    block.  Consume the entire block.  */
 ++nesting_depth;
 break;

case CPP_PRAGMA:
 /* If we see a pragma, consume the whole thing at once.  We
    have some safeguards against consuming pragmas willy-nilly.
    Normally, we'd expect to be here with parser->error set,
    which disables these safeguards.  But it's possible to get
    here for secondary error recovery, after parser->error has
    been cleared.  */
 c_parser_consume_pragma (parser);
 c_parser_skip_to_pragma_eol (parser);
 parser->error = save_error;
 continue;

default:
 break;
}

    c_parser_consume_token (parser);
  }

finished:
parser->error = false;
1415}

1417/* CPP's options (initialized by c-opts.c).  */
1418extern cpp_options *cpp_opts;

1420/* Save the warning flags which are controlled by __extension__.  */

1422static inline int
1423disable_extension_diagnostics (void)
1424{
int ret = (pedanticglobal_options.x_pedantic
    | (warn_pointer_arithglobal_options.x_warn_pointer_arith << 1)
    | (warn_traditionalglobal_options.x_warn_traditional << 2)
    | (flag_iso << 3)
    | (warn_long_longglobal_options.x_warn_long_long << 4)
    | (warn_cxx_compatglobal_options.x_warn_cxx_compat << 5)
    | (warn_overlength_stringsglobal_options.x_warn_overlength_strings << 6)
    /* warn_c90_c99_compat has three states: -1/0/1, so we must
play tricks to properly restore it.  */
    | ((warn_c90_c99_compatglobal_options.x_warn_c90_c99_compat == 1) << 7)
    | ((warn_c90_c99_compatglobal_options.x_warn_c90_c99_compat == -1) << 8)
    /* Similarly for warn_c99_c11_compat.  */
    | ((warn_c99_c11_compatglobal_options.x_warn_c99_c11_compat == 1) << 9)
    | ((warn_c99_c11_compatglobal_options.x_warn_c99_c11_compat == -1) << 10)
    /* Similarly for warn_c11_c2x_compat.  */
    | ((warn_c11_c2x_compatglobal_options.x_warn_c11_c2x_compat == 1) << 11)
    | ((warn_c11_c2x_compatglobal_options.x_warn_c11_c2x_compat == -1) << 12)
    );
cpp_opts->cpp_pedantic = pedanticglobal_options.x_pedantic = 0;
warn_pointer_arithglobal_options.x_warn_pointer_arith = 0;
cpp_opts->cpp_warn_traditional = warn_traditionalglobal_options.x_warn_traditional = 0;
flag_iso = 0;
cpp_opts->cpp_warn_long_long = warn_long_longglobal_options.x_warn_long_long = 0;
warn_cxx_compatglobal_options.x_warn_cxx_compat = 0;
warn_overlength_stringsglobal_options.x_warn_overlength_strings = 0;
warn_c90_c99_compatglobal_options.x_warn_c90_c99_compat = 0;
warn_c99_c11_compatglobal_options.x_warn_c99_c11_compat = 0;
warn_c11_c2x_compatglobal_options.x_warn_c11_c2x_compat = 0;
return ret;
1454}

1456/* Restore the warning flags which are controlled by __extension__.
 FLAGS is the return value from disable_extension_diagnostics.  */

1459static inline void
1460restore_extension_diagnostics (int flags)
1461{
cpp_opts->cpp_pedantic = pedanticglobal_options.x_pedantic = flags & 1;
warn_pointer_arithglobal_options.x_warn_pointer_arith = (flags >> 1) & 1;
cpp_opts->cpp_warn_traditional = warn_traditionalglobal_options.x_warn_traditional = (flags >> 2) & 1;
flag_iso = (flags >> 3) & 1;
cpp_opts->cpp_warn_long_long = warn_long_longglobal_options.x_warn_long_long = (flags >> 4) & 1;
warn_cxx_compatglobal_options.x_warn_cxx_compat = (flags >> 5) & 1;
warn_overlength_stringsglobal_options.x_warn_overlength_strings = (flags >> 6) & 1;
/* See above for why is this needed.  */
warn_c90_c99_compatglobal_options.x_warn_c90_c99_compat = (flags >> 7) & 1 ? 1 : ((flags >> 8) & 1 ? -1 : 0);
warn_c99_c11_compatglobal_options.x_warn_c99_c11_compat = (flags >> 9) & 1 ? 1 : ((flags >> 10) & 1 ? -1 : 0);
warn_c11_c2x_compatglobal_options.x_warn_c11_c2x_compat = (flags >> 11) & 1 ? 1 : ((flags >> 12) & 1 ? -1 : 0);
1473}

1475/* Helper data structure for parsing #pragma acc routine.  */
1476struct oacc_routine_data {
bool error_seen; /* Set if error has been reported.  */
bool fndecl_seen; /* Set if one fn decl/definition has been seen already.  */
tree clauses;
location_t loc;
1481};

1483/* Used for parsing objc foreach statements.  */
1484static tree objc_foreach_break_label, objc_foreach_continue_label;

1486static bool c_parser_nth_token_starts_std_attributes (c_parser *,
				      unsigned int);
1488static tree c_parser_std_attribute_specifier_sequence (c_parser *);
1489static void c_parser_external_declaration (c_parser *);
1490static void c_parser_asm_definition (c_parser *);
1491static void c_parser_declaration_or_fndef (c_parser *, bool, bool, bool,
			   bool, bool, tree *, vec<c_token>,
			   bool have_attrs = false,
			   tree attrs = NULL__null,
			   struct oacc_routine_data * = NULL__null,
			   bool * = NULL__null);
1497static void c_parser_static_assert_declaration_no_semi (c_parser *);
1498static void c_parser_static_assert_declaration (c_parser *);
1499static struct c_typespec c_parser_enum_specifier (c_parser *);
1500static struct c_typespec c_parser_struct_or_union_specifier (c_parser *);
1501static tree c_parser_struct_declaration (c_parser *);
1502static struct c_typespec c_parser_typeof_specifier (c_parser *);
1503static tree c_parser_alignas_specifier (c_parser *);
1504static struct c_declarator *c_parser_direct_declarator (c_parser *, bool,
					c_dtr_syn, bool *);
1506static struct c_declarator *c_parser_direct_declarator_inner (c_parser *,
					      bool,
					      struct c_declarator *);
1509static struct c_arg_info *c_parser_parms_declarator (c_parser *, bool, tree,
				     bool);
1511static struct c_arg_info *c_parser_parms_list_declarator (c_parser *, tree,
					  tree, bool);
1513static struct c_parm *c_parser_parameter_declaration (c_parser *, tree, bool);
1514static tree c_parser_simple_asm_expr (c_parser *);
1515static tree c_parser_gnu_attributes (c_parser *);
1516static struct c_expr c_parser_initializer (c_parser *);
1517static struct c_expr c_parser_braced_init (c_parser *, tree, bool,
			   struct obstack *);
1519static void c_parser_initelt (c_parser *, struct obstack *);
1520static void c_parser_initval (c_parser *, struct c_expr *,
	      struct obstack *);
1522static tree c_parser_compound_statement (c_parser *, location_t * = NULL__null);
1523static location_t c_parser_compound_statement_nostart (c_parser *);
1524static void c_parser_label (c_parser *, tree);
1525static void c_parser_statement (c_parser *, bool *, location_t * = NULL__null);
1526static void c_parser_statement_after_labels (c_parser *, bool *,
			     vec<tree> * = NULL__null);
1528static tree c_parser_c99_block_statement (c_parser *, bool *,
			  location_t * = NULL__null);
1530static void c_parser_if_statement (c_parser *, bool *, vec<tree> *);
1531static void c_parser_switch_statement (c_parser *, bool *);
1532static void c_parser_while_statement (c_parser *, bool, unsigned short, bool *);
1533static void c_parser_do_statement (c_parser *, bool, unsigned short);
1534static void c_parser_for_statement (c_parser *, bool, unsigned short, bool *);
1535static tree c_parser_asm_statement (c_parser *);
1536static tree c_parser_asm_operands (c_parser *);
1537static tree c_parser_asm_goto_operands (c_parser *);
1538static tree c_parser_asm_clobbers (c_parser *);
1539static struct c_expr c_parser_expr_no_commas (c_parser *, struct c_expr *,
			      tree = NULL_TREE(tree) __null);
1541static struct c_expr c_parser_conditional_expression (c_parser *,
				      struct c_expr *, tree);
1543static struct c_expr c_parser_binary_expression (c_parser *, struct c_expr *,
				 tree);
1545static struct c_expr c_parser_cast_expression (c_parser *, struct c_expr *);
1546static struct c_expr c_parser_unary_expression (c_parser *);
1547static struct c_expr c_parser_sizeof_expression (c_parser *);
1548static struct c_expr c_parser_alignof_expression (c_parser *);
1549static struct c_expr c_parser_postfix_expression (c_parser *);
1550static struct c_expr c_parser_postfix_expression_after_paren_type (c_parser *,
						   struct c_type_name *,
						   location_t);
1553static struct c_expr c_parser_postfix_expression_after_primary (c_parser *,
						location_t loc,
						struct c_expr);
1556static tree c_parser_transaction (c_parser *, enum rid);
1557static struct c_expr c_parser_transaction_expression (c_parser *, enum rid);
1558static tree c_parser_transaction_cancel (c_parser *);
1559static struct c_expr c_parser_expression (c_parser *);
1560static struct c_expr c_parser_expression_conv (c_parser *);
1561static vec<tree, va_gc> *c_parser_expr_list (c_parser *, bool, bool,
			     vec<tree, va_gc> **, location_t *,
			     tree *, vec<location_t> *,
			     unsigned int * = NULL__null);
1565static struct c_expr c_parser_has_attribute_expression (c_parser *);

1567static void c_parser_oacc_declare (c_parser *);
1568static void c_parser_oacc_enter_exit_data (c_parser *, bool);
1569static void c_parser_oacc_update (c_parser *);
1570static void c_parser_omp_construct (c_parser *, bool *);
1571static void c_parser_omp_threadprivate (c_parser *);
1572static void c_parser_omp_barrier (c_parser *);
1573static void c_parser_omp_depobj (c_parser *);
1574static void c_parser_omp_flush (c_parser *);
1575static tree c_parser_omp_for_loop (location_t, c_parser *, enum tree_code,
		   tree, tree *, bool *);
1577static void c_parser_omp_taskwait (c_parser *);
1578static void c_parser_omp_taskyield (c_parser *);
1579static void c_parser_omp_cancel (c_parser *);

1581enum pragma_context { pragma_external, pragma_struct, pragma_param,
      pragma_stmt, pragma_compound };
1583static bool c_parser_pragma (c_parser *, enum pragma_context, bool *);
1584static void c_parser_omp_cancellation_point (c_parser *, enum pragma_context);
1585static bool c_parser_omp_target (c_parser *, enum pragma_context, bool *);
1586static void c_parser_omp_end_declare_target (c_parser *);
1587static void c_parser_omp_declare (c_parser *, enum pragma_context);
1588static void c_parser_omp_requires (c_parser *);
1589static bool c_parser_omp_ordered (c_parser *, enum pragma_context, bool *);
1590static void c_parser_oacc_routine (c_parser *, enum pragma_context);

1592/* These Objective-C parser functions are only ever called when
 compiling Objective-C.  */
1594static void c_parser_objc_class_definition (c_parser *, tree);
1595static void c_parser_objc_class_instance_variables (c_parser *);
1596static void c_parser_objc_class_declaration (c_parser *);
1597static void c_parser_objc_alias_declaration (c_parser *);
1598static void c_parser_objc_protocol_definition (c_parser *, tree);
1599static bool c_parser_objc_method_type (c_parser *);
1600static void c_parser_objc_method_definition (c_parser *);
1601static void c_parser_objc_methodprotolist (c_parser *);
1602static void c_parser_objc_methodproto (c_parser *);
1603static tree c_parser_objc_method_decl (c_parser *, bool, tree *, tree *);
1604static tree c_parser_objc_type_name (c_parser *);
1605static tree c_parser_objc_protocol_refs (c_parser *);
1606static void c_parser_objc_try_catch_finally_statement (c_parser *);
1607static void c_parser_objc_synchronized_statement (c_parser *);
1608static tree c_parser_objc_selector (c_parser *);
1609static tree c_parser_objc_selector_arg (c_parser *);
1610static tree c_parser_objc_receiver (c_parser *);
1611static tree c_parser_objc_message_args (c_parser *);
1612static tree c_parser_objc_keywordexpr (c_parser *);
1613static void c_parser_objc_at_property_declaration (c_parser *);
1614static void c_parser_objc_at_synthesize_declaration (c_parser *);
1615static void c_parser_objc_at_dynamic_declaration (c_parser *);
1616static bool c_parser_objc_diagnose_bad_element_prefix
(c_parser *, struct c_declspecs *);
1618static location_t c_parser_parse_rtl_body (c_parser *, char *);

1620/* Parse a translation unit (C90 6.7, C99 6.9, C11 6.9).

 translation-unit:
   external-declarations

 external-declarations:
   external-declaration
   external-declarations external-declaration

 GNU extensions:

 translation-unit:
   empty
1633*/

1635static void
1636c_parser_translation_unit (c_parser *parser)
1637{
if (c_parser_next_token_is (parser, CPP_EOF))
  {
    pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
      "ISO C forbids an empty translation unit");
  }
else
  {
    void *obstack_position = obstack_alloc (&parser_obstack, 0)__extension__ ({ struct obstack *__h = (&parser_obstack);
 __extension__ ({ struct obstack *__o = (__h); size_t __len =
 ((0)); if (__extension__ ({ struct obstack const *__o1 = (__o
); (size_t) (__o1->chunk_limit - __o1->next_free); }) <
 __len) _obstack_newchunk (__o, __len); ((void) ((__o)->next_free
 += (__len))); }); __extension__ ({ struct obstack *__o1 = (__h
); void *__value = (void *) __o1->object_base; if (__o1->
next_free == __value) __o1->maybe_empty_object = 1; __o1->
next_free = ((sizeof (ptrdiff_t) < sizeof (void *) ? (__o1
->object_base) : (char *) 0) + (((__o1->next_free) - (sizeof
 (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (
char *) 0) + (__o1->alignment_mask)) & ~(__o1->alignment_mask
))); if ((size_t) (__o1->next_free - (char *) __o1->chunk
) > (size_t) (__o1->chunk_limit - (char *) __o1->chunk
)) __o1->next_free = __o1->chunk_limit; __o1->object_base
 = __o1->next_free; __value; }); });
    mark_valid_location_for_stdc_pragma (false);
    do
{
 ggc_collect ();
 c_parser_external_declaration (parser);
 obstack_free (&parser_obstack, obstack_position)__extension__ ({ struct obstack *__o = (&parser_obstack);
 void *__obj = (void *) (obstack_position); if (__obj > (void
 *) __o->chunk && __obj < (void *) __o->chunk_limit
) __o->next_free = __o->object_base = (char *) __obj; else
 _obstack_free (__o, __obj); });
}
    while (c_parser_next_token_is_not (parser, CPP_EOF));
  }

unsigned int i;
tree decl;
FOR_EACH_VEC_ELT (incomplete_record_decls, i, decl)for (i = 0; (incomplete_record_decls).iterate ((i), &(decl
)); ++(i))
  if (DECL_SIZE (decl)((contains_struct_check ((decl), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1659, __FUNCTION__))->decl_common.size) == NULL_TREE(tree) __null && TREE_TYPE (decl)((contains_struct_check ((decl), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1659, __FUNCTION__))->typed.type) != error_mark_nodeglobal_trees[TI_ERROR_MARK])
    error ("storage size of %q+D isn%'t known", decl);

if (current_omp_declare_target_attribute)
  {
    if (!errorcount(global_dc)->diagnostic_count[(int) (DK_ERROR)])
      error ("%<#pragma omp declare target%> without corresponding "
      "%<#pragma omp end declare target%>");
    current_omp_declare_target_attribute = 0;
  }
1669}

1671/* Parse an external declaration (C90 6.7, C99 6.9, C11 6.9).

 external-declaration:
   function-definition
   declaration

 GNU extensions:

 external-declaration:
   asm-definition
   ;
   __extension__ external-declaration

 Objective-C:

 external-declaration:
   objc-class-definition
   objc-class-declaration
   objc-alias-declaration
   objc-protocol-definition
   objc-method-definition
   @end
1693*/

1695static void
1696c_parser_external_declaration (c_parser *parser)
1697{
int ext;
switch (c_parser_peek_token (parser)->type)
  {
  case CPP_KEYWORD:
    switch (c_parser_peek_token (parser)->keyword)
{
case RID_EXTENSION:
 ext = disable_extension_diagnostics ();
 c_parser_consume_token (parser);
 c_parser_external_declaration (parser);
 restore_extension_diagnostics (ext);
 break;
case RID_ASM:
 c_parser_asm_definition (parser);
 break;
case RID_AT_INTERFACE:
case RID_AT_IMPLEMENTATION:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1715, __FUNCTION__), 0 : 0));
 c_parser_objc_class_definition (parser, NULL_TREE(tree) __null);
 break;
case RID_AT_CLASS:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1719, __FUNCTION__), 0 : 0));
 c_parser_objc_class_declaration (parser);
 break;
case RID_AT_ALIAS:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1723, __FUNCTION__), 0 : 0));
 c_parser_objc_alias_declaration (parser);
 break;
case RID_AT_PROTOCOL:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1727, __FUNCTION__), 0 : 0));
 c_parser_objc_protocol_definition (parser, NULL_TREE(tree) __null);
 break;
case RID_AT_PROPERTY:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1731, __FUNCTION__), 0 : 0));
 c_parser_objc_at_property_declaration (parser);
 break;
case RID_AT_SYNTHESIZE:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1735, __FUNCTION__), 0 : 0));
 c_parser_objc_at_synthesize_declaration (parser);
 break;
case RID_AT_DYNAMIC:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1739, __FUNCTION__), 0 : 0));
 c_parser_objc_at_dynamic_declaration (parser);
 break;
case RID_AT_END:
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1743, __FUNCTION__), 0 : 0));
 c_parser_consume_token (parser);
 objc_finish_implementation ();
 break;
default:
 goto decl_or_fndef;
}
    break;
  case CPP_SEMICOLON:
    pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
      "ISO C does not allow extra %<;%> outside of a function");
    c_parser_consume_token (parser);
    break;
  case CPP_PRAGMA:
    mark_valid_location_for_stdc_pragma (true);
    c_parser_pragma (parser, pragma_external, NULL__null);
    mark_valid_location_for_stdc_pragma (false);
    break;
  case CPP_PLUS:
  case CPP_MINUS:
    if (c_dialect_objc ()((c_language & clk_objc) != 0))
{
 c_parser_objc_method_definition (parser);
 break;
}
    /* Else fall through, and yield a syntax error trying to parse
as a declaration or function definition.  */
    /* FALLTHRU */
  default:
  decl_or_fndef:
    /* A declaration or a function definition (or, in Objective-C,
an @interface or @protocol with prefix attributes).  We can
only tell which after parsing the declaration specifiers, if
any, and the first declarator.  */
    c_parser_declaration_or_fndef (parser, true, true, true, false, true,
		     NULL__null, vNULL);
    break;
  }
1781}

1783static void c_finish_omp_declare_simd (c_parser *, tree, tree, vec<c_token>);
1784static void c_finish_oacc_routine (struct oacc_routine_data *, tree, bool);

1786/* Build and add a DEBUG_BEGIN_STMT statement with location LOC.  */

1788static void
1789add_debug_begin_stmt (location_t loc)
1790{
/* Don't add DEBUG_BEGIN_STMTs outside of functions, see PR84721.  */
if (!MAY_HAVE_DEBUG_MARKER_STMTSglobal_options.x_debug_nonbind_markers_p || !building_stmt_list_p ()((current_stmt_tree ()->x_cur_stmt_list) && !(current_stmt_tree
 ()->x_cur_stmt_list)->is_empty()))
  return;

tree stmt = build0 (DEBUG_BEGIN_STMT, void_type_nodeglobal_trees[TI_VOID_TYPE]);
SET_EXPR_LOCATION (stmt, loc)(expr_check (((stmt)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 1796, __FUNCTION__))->exp.locus = (loc);
add_stmt (stmt);
1798}

1800/* Parse a declaration or function definition (C90 6.5, 6.7.1, C99
 6.7, 6.9.1, C11 6.7, 6.9.1).  If FNDEF_OK is true, a function definition
 is accepted; otherwise (old-style parameter declarations) only other
 declarations are accepted.  If STATIC_ASSERT_OK is true, a static
 assertion is accepted; otherwise (old-style parameter declarations)
 it is not.  If NESTED is true, we are inside a function or parsing
 old-style parameter declarations; any functions encountered are
 nested functions and declaration specifiers are required; otherwise
 we are at top level and functions are normal functions and
 declaration specifiers may be optional.  If EMPTY_OK is true, empty
 declarations are OK (subject to all other constraints); otherwise
 (old-style parameter declarations) they are diagnosed.  If
 START_ATTR_OK is true, the declaration specifiers may start with
 attributes (GNU or standard); otherwise they may not.
 OBJC_FOREACH_OBJECT_DECLARATION can be used to get back the parsed
 declaration when parsing an Objective-C foreach statement.
 FALLTHRU_ATTR_P is used to signal whether this function parsed
 "__attribute__((fallthrough));".  ATTRS are any standard attributes
 parsed in the caller (in contexts where such attributes had to be
 parsed to determine whether what follows is a declaration or a
 statement); HAVE_ATTRS says whether there were any such attributes
 (even empty).

 declaration:
   declaration-specifiers init-declarator-list[opt] ;
   static_assert-declaration

 function-definition:
   declaration-specifiers[opt] declarator declaration-list[opt]
     compound-statement

 declaration-list:
   declaration
   declaration-list declaration

 init-declarator-list:
   init-declarator
   init-declarator-list , init-declarator

 init-declarator:
   declarator simple-asm-expr[opt] gnu-attributes[opt]
   declarator simple-asm-expr[opt] gnu-attributes[opt] = initializer

 GNU extensions:

 nested-function-definition:
   declaration-specifiers declarator declaration-list[opt]
     compound-statement

 attribute ;

 Objective-C:
   gnu-attributes objc-class-definition
   gnu-attributes objc-category-definition
   gnu-attributes objc-protocol-definition

 The simple-asm-expr and gnu-attributes are GNU extensions.

 This function does not handle __extension__; that is handled in its
 callers.  ??? Following the old parser, __extension__ may start
 external declarations, declarations in functions and declarations
 at the start of "for" loops, but not old-style parameter
 declarations.

 C99 requires declaration specifiers in a function definition; the
 absence is diagnosed through the diagnosis of implicit int.  In GNU
 C we also allow but diagnose declarations without declaration
 specifiers, but only at top level (elsewhere they conflict with
 other syntax).

 In Objective-C, declarations of the looping variable in a foreach
 statement are exceptionally terminated by 'in' (for example, 'for
 (NSObject *object in array) { ... }').

 OpenMP:

 declaration:
   threadprivate-directive

 GIMPLE:

 gimple-function-definition:
   declaration-specifiers[opt] __GIMPLE (gimple-or-rtl-pass-list) declarator
     declaration-list[opt] compound-statement

 rtl-function-definition:
   declaration-specifiers[opt] __RTL (gimple-or-rtl-pass-list) declarator
     declaration-list[opt] compound-statement  */

1889static void
1890c_parser_declaration_or_fndef (c_parser *parser, bool fndef_ok,
	       bool static_assert_ok, bool empty_ok,
	       bool nested, bool start_attr_ok,
	       tree *objc_foreach_object_declaration,
	       vec<c_token> omp_declare_simd_clauses,
	       bool have_attrs, tree attrs,
	       struct oacc_routine_data *oacc_routine_data,
	       bool *fallthru_attr_p)
1898{
struct c_declspecs *specs;
tree prefix_attrs;
tree all_prefix_attrs;
bool diagnosed_no_specs = false;
location_t here = c_parser_peek_token (parser)->location;

add_debug_begin_stmt (c_parser_peek_token (parser)->location);

if (static_assert_ok
    && c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
  {
    c_parser_static_assert_declaration (parser);
    return;
  }
specs = build_null_declspecs ();

/* Handle any standard attributes parsed in the caller.  */
if (have_attrs)
  {
    declspecs_add_attrs (here, specs, attrs);
    specs->non_std_attrs_seen_p = false;
  }

/* Try to detect an unknown type name when we have "A B" or "A *B".  */
if (c_parser_peek_token (parser)->type == CPP_NAME
    && c_parser_peek_token (parser)->id_kind == C_ID_ID
    && (c_parser_peek_2nd_token (parser)->type == CPP_NAME
        || c_parser_peek_2nd_token (parser)->type == CPP_MULT)
    && (!nested || !lookup_name (c_parser_peek_token (parser)->value)))
  {
    tree name = c_parser_peek_token (parser)->value;

    /* Issue a warning about NAME being an unknown type name, perhaps
with some kind of hint.
If the user forgot a "struct" etc, suggest inserting
it.  Otherwise, attempt to look for misspellings.  */
    gcc_rich_location richloc (here);
    if (tag_exists_p (RECORD_TYPE, name))
{
 /* This is not C++ with its implicit typedef.  */
 richloc.add_fixit_insert_before ("struct ");
 error_at (&richloc,
    "unknown type name %qE;"
    " use %<struct%> keyword to refer to the type",
    name);
}
    else if (tag_exists_p (UNION_TYPE, name))
{
 richloc.add_fixit_insert_before ("union ");
 error_at (&richloc,
    "unknown type name %qE;"
    " use %<union%> keyword to refer to the type",
    name);
}
    else if (tag_exists_p (ENUMERAL_TYPE, name))
{
 richloc.add_fixit_insert_before ("enum ");
 error_at (&richloc,
    "unknown type name %qE;"
    " use %<enum%> keyword to refer to the type",
    name);
}
    else
{
 auto_diagnostic_group d;
 name_hint hint = lookup_name_fuzzy (name, FUZZY_LOOKUP_TYPENAME,
			      here);
 if (const char *suggestion = hint.suggestion ())
   {
     richloc.add_fixit_replace (suggestion);
     error_at (&richloc,
	"unknown type name %qE; did you mean %qs?",
	name, suggestion);
   }
 else
   error_at (here, "unknown type name %qE", name);
}

    /* Parse declspecs normally to get a correct pointer type, but avoid
       a further "fails to be a type name" error.  Refuse nested functions
       since it is not how the user likely wants us to recover.  */
    c_parser_peek_token (parser)->type = CPP_KEYWORD;
    c_parser_peek_token (parser)->keyword = RID_VOID;
    c_parser_peek_token (parser)->value = error_mark_nodeglobal_trees[TI_ERROR_MARK];
    fndef_ok = !nested;
  }

/* When there are standard attributes at the start of the
   declaration (to apply to the entity being declared), an
   init-declarator-list or function definition must be present.  */
if (c_parser_nth_token_starts_std_attributes (parser, 1))
  have_attrs = true;

c_parser_declspecs (parser, specs, true, true, start_attr_ok,
      true, true, start_attr_ok, true, cla_nonabstract_decl);
if (parser->error)
  {
    c_parser_skip_to_end_of_block_or_statement (parser);
    return;
  }
if (nested && !specs->declspecs_seen_p)
  {
    c_parser_error (parser, "expected declaration specifiers");
    c_parser_skip_to_end_of_block_or_statement (parser);
    return;
  }

finish_declspecs (specs);
bool auto_type_p = specs->typespec_word == cts_auto_type;
if (c_parser_next_token_is (parser, CPP_SEMICOLON))
  {
    if (auto_type_p)
error_at (here, "%<__auto_type%> in empty declaration");
    else if (specs->typespec_kind == ctsk_none
      && attribute_fallthrough_p (specs->attrs))
{
 if (fallthru_attr_p != NULL__null)
   *fallthru_attr_p = true;
 if (nested)
   {
     tree fn = build_call_expr_internal_loc (here, IFN_FALLTHROUGH,
				      void_type_nodeglobal_trees[TI_VOID_TYPE], 0);
     add_stmt (fn);
   }
 else
   pedwarn (here, OPT_Wattributes,
     "%<fallthrough%> attribute at top level");
}
    else if (empty_ok && !(have_attrs
	     && specs->non_std_attrs_seen_p))
shadow_tag (specs);
    else
{
 shadow_tag_warned (specs, 1);
 pedwarn (here, 0, "empty declaration");
}
    c_parser_consume_token (parser);
    if (oacc_routine_data)
c_finish_oacc_routine (oacc_routine_data, NULL_TREE(tree) __null, false);
    return;
  }

/* Provide better error recovery.  Note that a type name here is usually
   better diagnosed as a redeclaration.  */
if (empty_ok
    && specs->typespec_kind == ctsk_tagdef
    && c_parser_next_token_starts_declspecs (parser)
    && !c_parser_next_token_is (parser, CPP_NAME))
  {
    c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
    parser->error = false;
    shadow_tag_warned (specs, 1);
    return;
  }
else if (c_dialect_objc ()((c_language & clk_objc) != 0) && !auto_type_p)
  {
    /* Prefix attributes are an error on method decls.  */
    switch (c_parser_peek_token (parser)->type)
{
 case CPP_PLUS:
 case CPP_MINUS:
   if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
     return;
   if (specs->attrs)
     {
warning_at (c_parser_peek_token (parser)->location, 
	    OPT_Wattributes,
      		    "prefix attributes are ignored for methods");
specs->attrs = NULL_TREE(tree) __null;
     }
   if (fndef_ok)
     c_parser_objc_method_definition (parser);
   else
     c_parser_objc_methodproto (parser);
   return;
   break;
 default:
   break;
}
    /* This is where we parse 'attributes @interface ...',
'attributes @implementation ...', 'attributes @protocol ...'
(where attributes could be, for example, __attribute__
((deprecated)).
    */
    switch (c_parser_peek_token (parser)->keyword)
{
case RID_AT_INTERFACE:
 {
   if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
     return;
   c_parser_objc_class_definition (parser, specs->attrs);
   return;
 }
 break;
case RID_AT_IMPLEMENTATION:
 {
   if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
     return;
   if (specs->attrs)
     {
warning_at (c_parser_peek_token (parser)->location, 
	OPT_Wattributes,
	"prefix attributes are ignored for implementations");
specs->attrs = NULL_TREE(tree) __null;
     }
   c_parser_objc_class_definition (parser, NULL_TREE(tree) __null);	    
   return;
 }
 break;
case RID_AT_PROTOCOL:
 {
   if (c_parser_objc_diagnose_bad_element_prefix (parser, specs))
     return;
   c_parser_objc_protocol_definition (parser, specs->attrs);
   return;
 }
 break;
case RID_AT_ALIAS:
case RID_AT_CLASS:
case RID_AT_END:
case RID_AT_PROPERTY:
 if (specs->attrs)
   {
     c_parser_error (parser, "unexpected attribute");
     specs->attrs = NULL__null;
   }
 break;
default:
 break;
}
  }
else if (attribute_fallthrough_p (specs->attrs))
  warning_at (here, OPT_Wattributes,
"%<fallthrough%> attribute not followed by %<;%>");

pending_xref_error ();
prefix_attrs = specs->attrs;
all_prefix_attrs = prefix_attrs;
specs->attrs = NULL_TREE(tree) __null;
while (true)
  {
    struct c_declarator *declarator;
    bool dummy = false;
    timevar_id_t tv;
    tree fnbody = NULL_TREE(tree) __null;
    /* Declaring either one or more declarators (in which case we
should diagnose if there were no declaration specifiers) or a
function definition (in which case the diagnostic for
implicit int suffices).  */
    declarator = c_parser_declarator (parser, 
			specs->typespec_kind != ctsk_none,
			C_DTR_NORMAL, &dummy);
    if (declarator == NULL__null)
{
 if (omp_declare_simd_clauses.exists ())
   c_finish_omp_declare_simd (parser, NULL_TREE(tree) __null, NULL_TREE(tree) __null,
		       omp_declare_simd_clauses);
 if (oacc_routine_data)
   c_finish_oacc_routine (oacc_routine_data, NULL_TREE(tree) __null, false);
 c_parser_skip_to_end_of_block_or_statement (parser);
 return;
}
    if (auto_type_p && declarator->kind != cdk_id)
{
 error_at (here,
    "%<__auto_type%> requires a plain identifier"
    " as declarator");
 c_parser_skip_to_end_of_block_or_statement (parser);
 return;
}
    if (c_parser_next_token_is (parser, CPP_EQ)
 || c_parser_next_token_is (parser, CPP_COMMA)
 || c_parser_next_token_is (parser, CPP_SEMICOLON)
 || c_parser_next_token_is_keyword (parser, RID_ASM)
 || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE)
 || c_parser_next_token_is_keyword (parser, RID_IN))
{
 tree asm_name = NULL_TREE(tree) __null;
 tree postfix_attrs = NULL_TREE(tree) __null;
 if (!diagnosed_no_specs && !specs->declspecs_seen_p)
   {
     diagnosed_no_specs = true;
     pedwarn (here, 0, "data definition has no type or storage class");
   }
 /* Having seen a data definition, there cannot now be a
    function definition.  */
 fndef_ok = false;
 if (c_parser_next_token_is_keyword (parser, RID_ASM))
   asm_name = c_parser_simple_asm_expr (parser);
 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
   {
     postfix_attrs = c_parser_gnu_attributes (parser);
     if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
{
  /* This means there is an attribute specifier after
     the declarator in a function definition.  Provide
     some more information for the user.  */
  error_at (here, "attributes should be specified before the "
	    "declarator in a function definition");
  c_parser_skip_to_end_of_block_or_statement (parser);
  return;
}
   }
 if (c_parser_next_token_is (parser, CPP_EQ))
   {
     tree d;
     struct c_expr init;
     location_t init_loc;
     c_parser_consume_token (parser);
     if (auto_type_p)
{
  init_loc = c_parser_peek_token (parser)->location;
  rich_location richloc (line_table, init_loc);
  start_init (NULL_TREE(tree) __null, asm_name, global_bindings_p (), &richloc);
  /* A parameter is initialized, which is invalid.  Don't
     attempt to instrument the initializer.  */
  int flag_sanitize_save = flag_sanitizeglobal_options.x_flag_sanitize;
  if (nested && !empty_ok)
    flag_sanitizeglobal_options.x_flag_sanitize = 0;
  init = c_parser_expr_no_commas (parser, NULL__null);
  flag_sanitizeglobal_options.x_flag_sanitize = flag_sanitize_save;
  if (TREE_CODE (init.value)((enum tree_code) (init.value)->base.code) == COMPONENT_REF
      && DECL_C_BIT_FIELD (TREE_OPERAND (init.value, 1))(((contains_struct_check (((tree_check (((*((const_cast<tree
*> (tree_operand_check ((init.value), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2221, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2221, __FUNCTION__, (FIELD_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2221, __FUNCTION__))->decl_common.lang_flag_4) == 1))
    error_at (here,
	      "%<__auto_type%> used with a bit-field"
	      " initializer");
  init = convert_lvalue_to_rvalue (init_loc, init, true, true);
  tree init_type = TREE_TYPE (init.value)((contains_struct_check ((init.value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2226, __FUNCTION__))->typed.type);
  bool vm_type = variably_modified_type_p (init_type,
					   NULL_TREE(tree) __null);
  if (vm_type)
    init.value = save_expr (init.value);
  finish_init ();
  specs->typespec_kind = ctsk_typeof;
  specs->locations[cdw_typedef] = init_loc;
  specs->typedef_p = true;
  specs->type = init_type;
  if (vm_type)
    {
      bool maybe_const = true;
      tree type_expr = c_fully_fold (init.value, false,
				     &maybe_const);
      specs->expr_const_operands &= maybe_const;
      if (specs->expr)
	specs->expr = build2 (COMPOUND_EXPR,
			      TREE_TYPE (type_expr)((contains_struct_check ((type_expr), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2244, __FUNCTION__))->typed.type),
			      specs->expr, type_expr);
      else
	specs->expr = type_expr;
    }
  d = start_decl (declarator, specs, true,
		  chainon (postfix_attrs, all_prefix_attrs));
  if (!d)
    d = error_mark_nodeglobal_trees[TI_ERROR_MARK];
  if (omp_declare_simd_clauses.exists ())
    c_finish_omp_declare_simd (parser, d, NULL_TREE(tree) __null,
			       omp_declare_simd_clauses);
}
     else
{
  /* The declaration of the variable is in effect while
     its initializer is parsed.  */
  d = start_decl (declarator, specs, true,
		  chainon (postfix_attrs, all_prefix_attrs));
  if (!d)
    d = error_mark_nodeglobal_trees[TI_ERROR_MARK];
  if (omp_declare_simd_clauses.exists ())
    c_finish_omp_declare_simd (parser, d, NULL_TREE(tree) __null,
			       omp_declare_simd_clauses);
  init_loc = c_parser_peek_token (parser)->location;
  rich_location richloc (line_table, init_loc);
  start_init (d, asm_name, global_bindings_p (), &richloc);
  /* A parameter is initialized, which is invalid.  Don't
     attempt to instrument the initializer.  */
  int flag_sanitize_save = flag_sanitizeglobal_options.x_flag_sanitize;
  if (TREE_CODE (d)((enum tree_code) (d)->base.code) == PARM_DECL)
    flag_sanitizeglobal_options.x_flag_sanitize = 0;
  init = c_parser_initializer (parser);
  flag_sanitizeglobal_options.x_flag_sanitize = flag_sanitize_save;
  finish_init ();
}
     if (oacc_routine_data)
c_finish_oacc_routine (oacc_routine_data, d, false);
     if (d != error_mark_nodeglobal_trees[TI_ERROR_MARK])
{
  maybe_warn_string_init (init_loc, TREE_TYPE (d)((contains_struct_check ((d), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2284, __FUNCTION__))->typed.type), init);
  finish_decl (d, init_loc, init.value,
	       init.original_type, asm_name);
}
   }
 else
   {
     if (auto_type_p)
{
  error_at (here,
	    "%<__auto_type%> requires an initialized "
	    "data declaration");
  c_parser_skip_to_end_of_block_or_statement (parser);
  return;
}

     location_t lastloc = UNKNOWN_LOCATION((location_t) 0);
     tree attrs = chainon (postfix_attrs, all_prefix_attrs);
     tree d = start_decl (declarator, specs, false, attrs, &lastloc);
     if (d && TREE_CODE (d)((enum tree_code) (d)->base.code) == FUNCTION_DECL)
{
  /* Find the innermost declarator that is neither cdk_id
     nor cdk_attrs.  */
  const struct c_declarator *decl = declarator;
  const struct c_declarator *last_non_id_attrs = NULL__null;

  while (decl)
    switch (decl->kind)
      {
      case cdk_array:
      case cdk_function:
      case cdk_pointer:
	last_non_id_attrs = decl;
	decl = decl->declarator;
	break;

      case cdk_attrs:
	decl = decl->declarator;
	break;

      case cdk_id:
	decl = 0;
	break;

      default:
	gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2329, __FUNCTION__));
      }

  /* If it exists and is cdk_function declaration whose
     arguments have not been set yet, use its arguments.  */
  if (last_non_id_attrs
      && last_non_id_attrs->kind == cdk_function)
    {
      tree parms = last_non_id_attrs->u.arg_info->parms;
      if (DECL_ARGUMENTS (d)((tree_check ((d), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2338, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
) == NULL_TREE(tree) __null
	  && DECL_INITIAL (d)((contains_struct_check ((d), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2339, __FUNCTION__))->decl_common.initial) == NULL_TREE(tree) __null)
	DECL_ARGUMENTS (d)((tree_check ((d), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2340, __FUNCTION__, (FUNCTION_DECL)))->function_decl.arguments
) = parms;

      warn_parm_array_mismatch (lastloc, d, parms);
    }
}
     if (omp_declare_simd_clauses.exists ())
{
  tree parms = NULL_TREE(tree) __null;
  if (d && TREE_CODE (d)((enum tree_code) (d)->base.code) == FUNCTION_DECL)
    {
      struct c_declarator *ce = declarator;
      while (ce != NULL__null)
	if (ce->kind == cdk_function)
	  {
	    parms = ce->u.arg_info->parms;
	    break;
	  }
	else
	  ce = ce->declarator;
    }
  if (parms)
    temp_store_parm_decls (d, parms);
  c_finish_omp_declare_simd (parser, d, parms,
			     omp_declare_simd_clauses);
  if (parms)
    temp_pop_parm_decls ();
}
     if (oacc_routine_data)
c_finish_oacc_routine (oacc_routine_data, d, false);
     if (d)
finish_decl (d, UNKNOWN_LOCATION((location_t) 0), NULL_TREE(tree) __null,
	     NULL_TREE(tree) __null, asm_name);

     if (c_parser_next_token_is_keyword (parser, RID_IN))
{
  if (d)
    *objc_foreach_object_declaration = d;
  else
    *objc_foreach_object_declaration = error_mark_nodeglobal_trees[TI_ERROR_MARK];		    
}
   }
 if (c_parser_next_token_is (parser, CPP_COMMA))
   {
     if (auto_type_p)
{
  error_at (here,
	    "%<__auto_type%> may only be used with"
	    " a single declarator");
  c_parser_skip_to_end_of_block_or_statement (parser);
  return;
}
     c_parser_consume_token (parser);
     if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
all_prefix_attrs = chainon (c_parser_gnu_attributes (parser),
			    prefix_attrs);
     else
all_prefix_attrs = prefix_attrs;
     continue;
   }
 else if (c_parser_next_token_is (parser, CPP_SEMICOLON))
   {
     c_parser_consume_token (parser);
     return;
   }
 else if (c_parser_next_token_is_keyword (parser, RID_IN))
   {
     /* This can only happen in Objective-C: we found the
 'in' that terminates the declaration inside an
 Objective-C foreach statement.  Do not consume the
 token, so that the caller can use it to determine
 that this indeed is a foreach context.  */
     return;
   }
 else
   {
     c_parser_error (parser, "expected %<,%> or %<;%>");
     c_parser_skip_to_end_of_block_or_statement (parser);
     return;
   }
}
    else if (auto_type_p)
{
 error_at (here,
    "%<__auto_type%> requires an initialized data declaration");
 c_parser_skip_to_end_of_block_or_statement (parser);
 return;
}
    else if (!fndef_ok)
{
 c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, "
	  "%<asm%> or %<__attribute__%>");
 c_parser_skip_to_end_of_block_or_statement (parser);
 return;
}
    /* Function definition (nested or otherwise).  */
    if (nested)
{
 pedwarn (here, OPT_Wpedantic, "ISO C forbids nested functions");
 c_push_function_context ();
}
    if (!start_function (specs, declarator, all_prefix_attrs))
{
 /* At this point we've consumed:
      declaration-specifiers declarator
    and the next token isn't CPP_EQ, CPP_COMMA, CPP_SEMICOLON,
    RID_ASM, RID_ATTRIBUTE, or RID_IN,
    but the
      declaration-specifiers declarator
    aren't grokkable as a function definition, so we have
    an error.  */
 gcc_assert (!c_parser_next_token_is (parser, CPP_SEMICOLON))((void)(!(!c_parser_next_token_is (parser, CPP_SEMICOLON)) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2450, __FUNCTION__), 0 : 0));
 if (c_parser_next_token_starts_declspecs (parser))
   {
     /* If we have
   declaration-specifiers declarator decl-specs
 then assume we have a missing semicolon, which would
 give us:
   declaration-specifiers declarator  decl-specs
				    ^
				    ;
   <~~~~~~~~~ declaration ~~~~~~~~~~>
 Use c_parser_require to get an error with a fix-it hint.  */
     c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>");
     parser->error = false;
   }
 else
   {
     /* This can appear in many cases looking nothing like a
 function definition, so we don't give a more specific
 error suggesting there was one.  */
     c_parser_error (parser, "expected %<=%>, %<,%>, %<;%>, %<asm%> "
	      "or %<__attribute__%>");
   }
 if (nested)
   c_pop_function_context ();
 break;
}

    if (DECL_DECLARED_INLINE_P (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2478, __FUNCTION__, (FUNCTION_DECL)))->function_decl.declared_inline_flag
))
      tv = TV_PARSE_INLINE;
    else
      tv = TV_PARSE_FUNC;
    auto_timevar at (g_timer, tv);

    /* Parse old-style parameter declarations.  ??? Attributes are
not allowed to start declaration specifiers here because of a
syntax conflict between a function declaration with attribute
suffix and a function definition with an attribute prefix on
first old-style parameter declaration.  Following the old
parser, they are not accepted on subsequent old-style
parameter declarations either.  However, there is no
ambiguity after the first declaration, nor indeed on the
first as long as we don't allow postfix attributes after a
declarator with a nonempty identifier list in a definition;
and postfix attributes have never been accepted here in
function definitions either.  */
    while (c_parser_next_token_is_not (parser, CPP_EOF)
    && c_parser_next_token_is_not (parser, CPP_OPEN_BRACE))
c_parser_declaration_or_fndef (parser, false, false, false,
		       true, false, NULL__null, vNULL);
    store_parm_decls ();
    if (omp_declare_simd_clauses.exists ())
c_finish_omp_declare_simd (parser, current_function_decl, NULL_TREE(tree) __null,
		   omp_declare_simd_clauses);
    if (oacc_routine_data)
c_finish_oacc_routine (oacc_routine_data, current_function_decl, true);
    location_t startloc = c_parser_peek_token (parser)->location;
    DECL_STRUCT_FUNCTION (current_function_decl)((tree_check ((current_function_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2507, __FUNCTION__, (FUNCTION_DECL)))->function_decl.f)->function_start_locus
= startloc;
    location_t endloc = startloc;

    /* If the definition was marked with __RTL, use the RTL parser now,
consuming the function body.  */
    if (specs->declspec_il == cdil_rtl)
{
 endloc = c_parser_parse_rtl_body (parser, specs->gimple_or_rtl_pass);

 /* Normally, store_parm_decls sets next_is_function_body,
    anticipating a function body.  We need a push_scope/pop_scope
    pair to flush out this state, or subsequent function parsing
    will go wrong.  */
 push_scope ();
 pop_scope ();

 finish_function (endloc);
 return;
}
    /* If the definition was marked with __GIMPLE then parse the
       function body as GIMPLE.  */
    else if (specs->declspec_il != cdil_none)
{
 bool saved = in_late_binary_op;
 in_late_binary_op = true;
 c_parser_parse_gimple_body (parser, specs->gimple_or_rtl_pass,
		      specs->declspec_il,
		      specs->entry_bb_count);
 in_late_binary_op = saved;
}
    else
fnbody = c_parser_compound_statement (parser, &endloc);
    tree fndecl = current_function_decl;
    if (nested)
{
 tree decl = current_function_decl;
 /* Mark nested functions as needing static-chain initially.
    lower_nested_functions will recompute it but the
    DECL_STATIC_CHAIN flag is also used before that happens,
    by initializer_constant_valid_p.  See gcc.dg/nested-fn-2.c.  */
 DECL_STATIC_CHAIN (decl)((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2548, __FUNCTION__, (FUNCTION_DECL)))->decl_with_vis.regdecl_flag
) = 1;
 add_stmt (fnbody);
 finish_function (endloc);
 c_pop_function_context ();
 add_stmt (build_stmt (DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2552, __FUNCTION__))->decl_minimal.locus), DECL_EXPR, decl));
}
    else
{
 if (fnbody)
   add_stmt (fnbody);
 finish_function (endloc);
}
    /* Get rid of the empty stmt list for GIMPLE/RTL.  */
    if (specs->declspec_il != cdil_none)
DECL_SAVED_TREE (fndecl)((tree_check ((fndecl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2562, __FUNCTION__, (FUNCTION_DECL)))->function_decl.saved_tree
) = NULL_TREE(tree) __null;

    break;
  }
2566}

2568/* Parse an asm-definition (asm() outside a function body).  This is a
 GNU extension.

 asm-definition:
   simple-asm-expr ;
2573*/

2575static void
2576c_parser_asm_definition (c_parser *parser)
2577{
tree asm_str = c_parser_simple_asm_expr (parser);
if (asm_str)
  symtab->finalize_toplevel_asm (asm_str);
c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
2582}

2584/* Parse a static assertion (C11 6.7.10).

 static_assert-declaration:
   static_assert-declaration-no-semi ;
2588*/

2590static void
2591c_parser_static_assert_declaration (c_parser *parser)
2592{
c_parser_static_assert_declaration_no_semi (parser);
if (parser->error
    || !c_parser_require (parser, CPP_SEMICOLON, "expected %<;%>"))
  c_parser_skip_to_end_of_block_or_statement (parser);
2597}

2599/* Parse a static assertion (C11 6.7.10), without the trailing
 semicolon.

 static_assert-declaration-no-semi:
   _Static_assert ( constant-expression , string-literal )

 C2X:
 static_assert-declaration-no-semi:
   _Static_assert ( constant-expression )
2608*/

2610static void
2611c_parser_static_assert_declaration_no_semi (c_parser *parser)
2612{
location_t assert_loc, value_loc;
tree value;
tree string = NULL_TREE(tree) __null;

gcc_assert (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))((void)(!(c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2617, __FUNCTION__), 0 : 0));
assert_loc = c_parser_peek_token (parser)->location;
if (flag_isoc99)
  pedwarn_c99 (assert_loc, OPT_Wpedantic,
 "ISO C99 does not support %<_Static_assert%>");
else
  pedwarn_c99 (assert_loc, OPT_Wpedantic,
 "ISO C90 does not support %<_Static_assert%>");
c_parser_consume_token (parser);
matching_parens parens;
if (!parens.require_open (parser))
  return;
location_t value_tok_loc = c_parser_peek_token (parser)->location;
value = c_parser_expr_no_commas (parser, NULL__null).value;
value_loc = EXPR_LOC_OR_LOC (value, value_tok_loc)((((IS_ADHOC_LOC (((((value)) && ((tree_code_type[(int
) (((enum tree_code) ((value))->base.code))]) >= tcc_reference
 && (tree_code_type[(int) (((enum tree_code) ((value)
)->base.code))]) <= tcc_expression)) ? (value)->exp.
locus : ((location_t) 0)))) ? get_location_from_adhoc_loc (line_table
, ((((value)) && ((tree_code_type[(int) (((enum tree_code
) ((value))->base.code))]) >= tcc_reference && (
tree_code_type[(int) (((enum tree_code) ((value))->base.code
))]) <= tcc_expression)) ? (value)->exp.locus : ((location_t
) 0))) : (((((value)) && ((tree_code_type[(int) (((enum
 tree_code) ((value))->base.code))]) >= tcc_reference &&
 (tree_code_type[(int) (((enum tree_code) ((value))->base.
code))]) <= tcc_expression)) ? (value)->exp.locus : ((location_t
) 0)))) != ((location_t) 0)) ? (value)->exp.locus : (value_tok_loc
));
if (c_parser_next_token_is (parser, CPP_COMMA))
  {
    c_parser_consume_token (parser);
    switch (c_parser_peek_token (parser)->type)
{
case CPP_STRING:
case CPP_STRING16:
case CPP_STRING32:
case CPP_WSTRING:
case CPP_UTF8STRING:
 string = c_parser_string_literal (parser, false, true).value;
 break;
default:
 c_parser_error (parser, "expected string literal");
 return;
}
  }
else if (flag_isoc11)
  /* If pedantic for pre-C11, the use of _Static_assert itself will
     have been diagnosed, so do not also diagnose the use of this
     new C2X feature of _Static_assert.  */
  pedwarn_c11 (assert_loc, OPT_Wpedantic,
 "ISO C11 does not support omitting the string in "
 "%<_Static_assert%>");
parens.require_close (parser);

if (!INTEGRAL_TYPE_P (TREE_TYPE (value))(((enum tree_code) (((contains_struct_check ((value), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2658, __FUNCTION__))->typed.type))->base.code) == ENUMERAL_TYPE
 || ((enum tree_code) (((contains_struct_check ((value), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2658, __FUNCTION__))->typed.type))->base.code) == BOOLEAN_TYPE
 || ((enum tree_code) (((contains_struct_check ((value), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2658, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE
))
  {
    error_at (value_loc, "expression in static assertion is not an integer");
    return;
  }
if (TREE_CODE (value)((enum tree_code) (value)->base.code) != INTEGER_CST)
  {
    value = c_fully_fold (value, false, NULL__null);
    /* Strip no-op conversions.  */
    STRIP_TYPE_NOPS (value)while ((((((enum tree_code) (value)->base.code)) == NOP_EXPR
 || (((enum tree_code) (value)->base.code)) == CONVERT_EXPR
) || ((enum tree_code) (value)->base.code) == NON_LVALUE_EXPR
) && (*((const_cast<tree*> (tree_operand_check (
(value), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2667, __FUNCTION__))))) != global_trees[TI_ERROR_MARK] &&
 (((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2667, __FUNCTION__))->typed.type) == ((contains_struct_check
 (((*((const_cast<tree*> (tree_operand_check ((value), (
0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2667, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2667, __FUNCTION__))->typed.type))) (value) = (*((const_cast
<tree*> (tree_operand_check ((value), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2667, __FUNCTION__)))));
    if (TREE_CODE (value)((enum tree_code) (value)->base.code) == INTEGER_CST)
pedwarn (value_loc, OPT_Wpedantic, "expression in static assertion "
 "is not an integer constant expression");
  }
if (TREE_CODE (value)((enum tree_code) (value)->base.code) != INTEGER_CST)
  {
    error_at (value_loc, "expression in static assertion is not constant");
    return;
  }
constant_expression_warning (value);
if (integer_zerop (value))
  {
    if (string)
error_at (assert_loc, "static assertion failed: %E", string);
    else
error_at (assert_loc, "static assertion failed");
  }
2685}

2687/* Parse some declaration specifiers (possibly none) (C90 6.5, C99
 6.7, C11 6.7), adding them to SPECS (which may already include some).
 Storage class specifiers are accepted iff SCSPEC_OK; type
 specifiers are accepted iff TYPESPEC_OK; alignment specifiers are
 accepted iff ALIGNSPEC_OK; gnu-attributes are accepted at the start
 iff START_ATTR_OK; __auto_type is accepted iff AUTO_TYPE_OK.  In
 addition to the syntax shown, standard attributes are accepted at
 the start iff START_STD_ATTR_OK and at the end iff END_STD_ATTR_OK;
 unlike gnu-attributes, they are not accepted in the middle of the
 list.  (This combines various different syntax productions in the C
 standard, and in some cases gnu-attributes and standard attributes
 at the start may already have been parsed before this function is
 called.)

 declaration-specifiers:
   storage-class-specifier declaration-specifiers[opt]
   type-specifier declaration-specifiers[opt]
   type-qualifier declaration-specifiers[opt]
   function-specifier declaration-specifiers[opt]
   alignment-specifier declaration-specifiers[opt]

 Function specifiers (inline) are from C99, and are currently
 handled as storage class specifiers, as is __thread.  Alignment
 specifiers are from C11.

 C90 6.5.1, C99 6.7.1, C11 6.7.1:
 storage-class-specifier:
   typedef
   extern
   static
   auto
   register
   _Thread_local

 (_Thread_local is new in C11.)

 C99 6.7.4, C11 6.7.4:
 function-specifier:
   inline
   _Noreturn

 (_Noreturn is new in C11.)

 C90 6.5.2, C99 6.7.2, C11 6.7.2:
 type-specifier:
   void
   char
   short
   int
   long
   float
   double
   signed
   unsigned
   _Bool
   _Complex
   [_Imaginary removed in C99 TC2]
   struct-or-union-specifier
   enum-specifier
   typedef-name
   atomic-type-specifier

 (_Bool and _Complex are new in C99.)
 (atomic-type-specifier is new in C11.)

 C90 6.5.3, C99 6.7.3, C11 6.7.3:

 type-qualifier:
   const
   restrict
   volatile
   address-space-qualifier
   _Atomic

 (restrict is new in C99.)
 (_Atomic is new in C11.)

 GNU extensions:

 declaration-specifiers:
   gnu-attributes declaration-specifiers[opt]

 type-qualifier:
   address-space

 address-space:
   identifier recognized by the target

 storage-class-specifier:
   __thread

 type-specifier:
   typeof-specifier
   __auto_type
   __intN
   _Decimal32
   _Decimal64
   _Decimal128
   _Fract
   _Accum
   _Sat

(_Fract, _Accum, and _Sat are new from ISO/IEC DTR 18037:
 http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1169.pdf)

 atomic-type-specifier
  _Atomic ( type-name )

 Objective-C:

 type-specifier:
   class-name objc-protocol-refs[opt]
   typedef-name objc-protocol-refs
   objc-protocol-refs
2801*/

2803void
2804c_parser_declspecs (c_parser *parser, struct c_declspecs *specs,
    bool scspec_ok, bool typespec_ok, bool start_attr_ok,
    bool alignspec_ok, bool auto_type_ok,
    bool start_std_attr_ok, bool end_std_attr_ok,
    enum c_lookahead_kind la)
2809{
bool attrs_ok = start_attr_ok;
bool seen_type = specs->typespec_kind != ctsk_none;

if (!typespec_ok)
  gcc_assert (la == cla_prefer_id)((void)(!(la == cla_prefer_id) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2814, __FUNCTION__), 0 : 0));

if (start_std_attr_ok
    && c_parser_nth_token_starts_std_attributes (parser, 1))
  {
    gcc_assert (!specs->non_std_attrs_seen_p)((void)(!(!specs->non_std_attrs_seen_p) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2819, __FUNCTION__), 0 : 0));
    location_t loc = c_parser_peek_token (parser)->location;
    tree attrs = c_parser_std_attribute_specifier_sequence (parser);
    declspecs_add_attrs (loc, specs, attrs);
    specs->non_std_attrs_seen_p = false;
  }

while (c_parser_next_token_is (parser, CPP_NAME)
|| c_parser_next_token_is (parser, CPP_KEYWORD)
|| (c_dialect_objc ()((c_language & clk_objc) != 0) && c_parser_next_token_is (parser, CPP_LESS)))
  {
    struct c_typespec t;
    tree attrs;
    tree align;
    location_t loc = c_parser_peek_token (parser)->location;

    /* 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)
 && !c_parser_next_token_is_keyword (parser, RID_ALIGNAS))
break;

    if (c_parser_next_token_is (parser, CPP_NAME))
{
 c_token *name_token = c_parser_peek_token (parser);
 tree value = name_token->value;
 c_id_kind kind = name_token->id_kind;

 if (kind == C_ID_ADDRSPACE)
   {
     addr_space_t as
= name_token->keyword - RID_FIRST_ADDR_SPACE;
     declspecs_add_addrspace (name_token->location, specs, as);
     c_parser_consume_token (parser);
     attrs_ok = true;
     continue;
   }

 gcc_assert (!c_parser_next_token_is_qualifier (parser))((void)(!(!c_parser_next_token_is_qualifier (parser)) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2861, __FUNCTION__), 0 : 0));

 /* 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_ID)
   {
     error_at (loc, "unknown type name %qE", value);
     t.kind = ctsk_typedef;
     t.spec = error_mark_nodeglobal_trees[TI_ERROR_MARK];
   }
 else if (kind == C_ID_TYPENAME
          && (!c_dialect_objc ()((c_language & clk_objc) != 0)
              || 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);
   }
 else
   {
     tree proto = NULL_TREE(tree) __null;
     gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2893, __FUNCTION__), 0 : 0));
     t.kind = ctsk_objc;
     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(tree) __null;
 t.expr_const_operands = true;
 declspecs_add_type (name_token->location, specs, t);
 continue;
}
    if (c_parser_next_token_is (parser, CPP_LESS))
{
 /* Make "<SomeProtocol>" equivalent to "id <SomeProtocol>" -
    nisse@lysator.liu.se.  */
 tree proto;
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2909, __FUNCTION__), 0 : 0));
 if (!typespec_ok || seen_type)
   break;
 proto = c_parser_objc_protocol_refs (parser);
 t.kind = ctsk_objc;
 t.spec = objc_get_protocol_qualified_type (NULL_TREE(tree) __null, proto);
 t.expr = NULL_TREE(tree) __null;
 t.expr_const_operands = true;
 declspecs_add_type (loc, specs, t);
 continue;
}
    gcc_assert (c_parser_next_token_is (parser, CPP_KEYWORD))((void)(!(c_parser_next_token_is (parser, CPP_KEYWORD)) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 2920, __FUNCTION__), 0 : 0));
    switch (c_parser_peek_token (parser)->keyword)
{
case RID_STATIC:
case RID_EXTERN:
case RID_REGISTER:
case RID_TYPEDEF:
case RID_INLINE:
case RID_NORETURN:
case RID_AUTO:
case RID_THREAD:
 if (!scspec_ok)
   goto out;
 attrs_ok = true;
 /* TODO: Distinguish between function specifiers (inline, noreturn)
    and storage class specifiers, either here or in
    declspecs_add_scspec.  */
 declspecs_add_scspec (loc, specs,
		c_parser_peek_token (parser)->value);
 c_parser_consume_token (parser);
 break;
case RID_AUTO_TYPE:
 if (!auto_type_ok)
   goto out;
 /* Fall through.  */
case RID_UNSIGNED:
case RID_LONG:
case RID_SHORT:
case RID_SIGNED:
case RID_COMPLEX:
case RID_INT:
case RID_CHAR:
case RID_FLOAT:
case RID_DOUBLE:
case RID_VOID:
case RID_DFLOAT32:
case RID_DFLOAT64:
case RID_DFLOAT128:
CASE_RID_FLOATN_NXcase RID_FLOAT16: case RID_FLOAT32: case RID_FLOAT64: case RID_FLOAT128
: case RID_FLOAT32X: case RID_FLOAT64X: case RID_FLOAT128X:
case RID_BOOL:
case RID_FRACT:
case RID_ACCUM:
case RID_SAT:
case RID_INT_N_0:
case RID_INT_N_1:
case RID_INT_N_2:
case RID_INT_N_3:
 if (!typespec_ok)
   goto out;
 attrs_ok = true;
 seen_type = true;
 if (c_dialect_objc ()((c_language & clk_objc) != 0))
   parser->objc_need_raw_identifier = true;
 t.kind = ctsk_resword;
 t.spec = c_parser_peek_token (parser)->value;
 t.expr = NULL_TREE(tree) __null;
 t.expr_const_operands = true;
 declspecs_add_type (loc, specs, t);
 c_parser_consume_token (parser);
 break;
case RID_ENUM:
 if (!typespec_ok)
   goto out;
 attrs_ok = true;
 seen_type = true;
 t = c_parser_enum_specifier (parser);
        invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
 declspecs_add_type (loc, specs, t);
 break;
case RID_STRUCT:
case RID_UNION:
 if (!typespec_ok)
   goto out;
 attrs_ok = true;
 seen_type = true;
 t = c_parser_struct_or_union_specifier (parser);
        invoke_plugin_callbacks (PLUGIN_FINISH_TYPE, t.spec);
 declspecs_add_type (loc, specs, t);
 break;
case RID_TYPEOF:
 /* ??? The old parser rejected typeof after other type
    specifiers, but is a syntax error the best way of
    handling this?  */
 if (!typespec_ok || seen_type)
   goto out;
 attrs_ok = true;
 seen_type = true;
 t = c_parser_typeof_specifier (parser);
 declspecs_add_type (loc, specs, t);
 break;
case RID_ATOMIC:
 /* C parser handling of Objective-C constructs needs
    checking for correct lvalue-to-rvalue conversions, and
    the code in build_modify_expr handling various
    Objective-C cases, and that in build_unary_op handling
    Objective-C cases for increment / decrement, also needs
    updating; uses of TYPE_MAIN_VARIANT in objc_compare_types
    and objc_types_are_equivalent may also need updates.  */
 if (c_dialect_objc ()((c_language & clk_objc) != 0))
   sorry ("%<_Atomic%> in Objective-C");
 if (flag_isoc99)
   pedwarn_c99 (loc, OPT_Wpedantic,
	 "ISO C99 does not support the %<_Atomic%> qualifier");
 else
   pedwarn_c99 (loc, OPT_Wpedantic,
	 "ISO C90 does not support the %<_Atomic%> qualifier");
 attrs_ok = true;
 tree value;
 value = c_parser_peek_token (parser)->value;
 c_parser_consume_token (parser);
 if (typespec_ok && c_parser_next_token_is (parser, CPP_OPEN_PAREN))
   {
     /* _Atomic ( type-name ).  */
     seen_type = true;
     c_parser_consume_token (parser);
     struct c_type_name *type = c_parser_type_name (parser);
     t.kind = ctsk_typeof;
     t.spec = error_mark_nodeglobal_trees[TI_ERROR_MARK];
     t.expr = NULL_TREE(tree) __null;
     t.expr_const_operands = true;
     if (type != NULL__null)
t.spec = groktypename (type, &t.expr,
		       &t.expr_const_operands);
     c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
			 "expected %<)%>");
     if (t.spec != error_mark_nodeglobal_trees[TI_ERROR_MARK])
{
  if (TREE_CODE (t.spec)((enum tree_code) (t.spec)->base.code) == ARRAY_TYPE)
    error_at (loc, "%<_Atomic%>-qualified array type");
  else if (TREE_CODE (t.spec)((enum tree_code) (t.spec)->base.code) == FUNCTION_TYPE)
    error_at (loc, "%<_Atomic%>-qualified function type");
  else if (TYPE_QUALS (t.spec)((int) ((((tree_class_check ((t.spec), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3051, __FUNCTION__))->base.readonly_flag) * TYPE_QUAL_CONST
) | (((tree_class_check ((t.spec), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3051, __FUNCTION__))->base.volatile_flag) * TYPE_QUAL_VOLATILE
) | (((tree_class_check ((t.spec), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3051, __FUNCTION__))->base.u.bits.atomic_flag) * TYPE_QUAL_ATOMIC
) | (((tree_class_check ((t.spec), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3051, __FUNCTION__))->type_common.restrict_flag) * TYPE_QUAL_RESTRICT
) | (((((tree_class_check ((t.spec), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3051, __FUNCTION__))->base.u.bits.address_space) & 0xFF
) << 8)))) != TYPE_UNQUALIFIED)
    error_at (loc, "%<_Atomic%> applied to a qualified type");
  else
    t.spec = c_build_qualified_type (t.spec, TYPE_QUAL_ATOMIC);
}
     declspecs_add_type (loc, specs, t);
   }
 else
   declspecs_add_qual (loc, specs, value);
 break;
case RID_CONST:
case RID_VOLATILE:
case RID_RESTRICT:
 attrs_ok = true;
 declspecs_add_qual (loc, specs, c_parser_peek_token (parser)->value);
 c_parser_consume_token (parser);
 break;
case RID_ATTRIBUTE:
 if (!attrs_ok)
   goto out;
 attrs = c_parser_gnu_attributes (parser);
 declspecs_add_attrs (loc, specs, attrs);
 break;
case RID_ALIGNAS:
 if (!alignspec_ok)
   goto out;
 align = c_parser_alignas_specifier (parser);
 declspecs_add_alignas (loc, specs, align);
 break;
case RID_GIMPLE:
 if (! flag_gimpleglobal_options.x_flag_gimple)
   error_at (loc, "%<__GIMPLE%> only valid with %<-fgimple%>");
 c_parser_consume_token (parser);
 specs->declspec_il = cdil_gimple;
 specs->locations[cdw_gimple] = loc;
 c_parser_gimple_or_rtl_pass_list (parser, specs);
 break;
case RID_RTL:
 c_parser_consume_token (parser);
 specs->declspec_il = cdil_rtl;
 specs->locations[cdw_rtl] = loc;
 c_parser_gimple_or_rtl_pass_list (parser, specs);
 break;
default:
 goto out;
}
  }
out:
if (end_std_attr_ok
    && c_parser_nth_token_starts_std_attributes (parser, 1))
  specs->postfix_attrs = c_parser_std_attribute_specifier_sequence (parser);
3102}

3104/* Parse an enum specifier (C90 6.5.2.2, C99 6.7.2.2, C11 6.7.2.2).

 enum-specifier:
   enum gnu-attributes[opt] identifier[opt] { enumerator-list }
     gnu-attributes[opt]
   enum gnu-attributes[opt] identifier[opt] { enumerator-list , }
     gnu-attributes[opt]
   enum gnu-attributes[opt] identifier

 The form with trailing comma is new in C99.  The forms with
 gnu-attributes are GNU extensions.  In GNU C, we accept any expression
 without commas in the syntax (assignment expressions, not just
 conditional expressions); assignment expressions will be diagnosed
 as non-constant.

 enumerator-list:
   enumerator
   enumerator-list , enumerator

 enumerator:
   enumeration-constant attribute-specifier-sequence[opt]
   enumeration-constant attribute-specifier-sequence[opt]
     = constant-expression

 GNU Extensions:

 enumerator:
   enumeration-constant attribute-specifier-sequence[opt] gnu-attributes[opt]
   enumeration-constant attribute-specifier-sequence[opt] gnu-attributes[opt]
     = constant-expression

3135*/

3137static struct c_typespec
3138c_parser_enum_specifier (c_parser *parser)
3139{
struct c_typespec ret;
bool have_std_attrs;
tree std_attrs = NULL_TREE(tree) __null;
tree attrs;
tree ident = NULL_TREE(tree) __null;
location_t enum_loc;
location_t ident_loc = UNKNOWN_LOCATION((location_t) 0);  /* Quiet warning.  */
gcc_assert (c_parser_next_token_is_keyword (parser, RID_ENUM))((void)(!(c_parser_next_token_is_keyword (parser, RID_ENUM)) ?
 fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3147, __FUNCTION__), 0 : 0));
c_parser_consume_token (parser);
have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
if (have_std_attrs)
  std_attrs = c_parser_std_attribute_specifier_sequence (parser);
attrs = c_parser_gnu_attributes (parser);
enum_loc = c_parser_peek_token (parser)->location;
/* Set the location in case we create a decl now.  */
c_parser_set_source_position_from_token (c_parser_peek_token (parser));
if (c_parser_next_token_is (parser, CPP_NAME))
  {
    ident = c_parser_peek_token (parser)->value;
    ident_loc = c_parser_peek_token (parser)->location;
    enum_loc = ident_loc;
    c_parser_consume_token (parser);
  }
if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
  {
    /* Parse an enum definition.  */
    struct c_enum_contents the_enum;
    tree type;
    tree postfix_attrs;
    /* We chain the enumerators in reverse order, then put them in
forward order at the end.  */
    tree values;
    timevar_push (TV_PARSE_ENUM);
    type = start_enum (enum_loc, &the_enum, ident);
    values = NULL_TREE(tree) __null;
    c_parser_consume_token (parser);
    while (true)
{
 tree enum_id;
 tree enum_value;
 tree enum_decl;
 bool seen_comma;
 c_token *token;
 location_t comma_loc = UNKNOWN_LOCATION((location_t) 0);  /* Quiet warning.  */
 location_t decl_loc, value_loc;
 if (c_parser_next_token_is_not (parser, CPP_NAME))
   {
     /* Give a nicer error for "enum {}".  */
     if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
  && !parser->error)
{
  error_at (c_parser_peek_token (parser)->location,
	    "empty enum is invalid");
  parser->error = true;
}
     else
c_parser_error (parser, "expected identifier");
     c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL__null);
     values = error_mark_nodeglobal_trees[TI_ERROR_MARK];
     break;
   }
 token = c_parser_peek_token (parser);
 enum_id = token->value;
 /* Set the location in case we create a decl now.  */
 c_parser_set_source_position_from_token (token);
 decl_loc = value_loc = token->location;
 c_parser_consume_token (parser);
 /* Parse any specified attributes.  */
 tree std_attrs = NULL_TREE(tree) __null;
 if (c_parser_nth_token_starts_std_attributes (parser, 1))
   std_attrs = c_parser_std_attribute_specifier_sequence (parser);
 tree enum_attrs = chainon (std_attrs,
		     c_parser_gnu_attributes (parser));
 if (c_parser_next_token_is (parser, CPP_EQ))
   {
     c_parser_consume_token (parser);
     value_loc = c_parser_peek_token (parser)->location;
     enum_value = c_parser_expr_no_commas (parser, NULL__null).value;
   }
 else
   enum_value = NULL_TREE(tree) __null;
 enum_decl = build_enumerator (decl_loc, value_loc,
			&the_enum, enum_id, enum_value);
 if (enum_attrs)
   decl_attributes (&TREE_PURPOSE (enum_decl)((tree_check ((enum_decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3224, __FUNCTION__, (TREE_LIST)))->list.purpose), enum_attrs, 0);
 TREE_CHAIN (enum_decl)((contains_struct_check ((enum_decl), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3225, __FUNCTION__))->common.chain) = values;
 values = enum_decl;
 seen_comma = false;
 if (c_parser_next_token_is (parser, CPP_COMMA))
   {
     comma_loc = c_parser_peek_token (parser)->location;
     seen_comma = true;
     c_parser_consume_token (parser);
   }
 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
   {
     if (seen_comma)
pedwarn_c90 (comma_loc, OPT_Wpedantic,
	     "comma at end of enumerator list");
     c_parser_consume_token (parser);
     break;
   }
 if (!seen_comma)
   {
     c_parser_error (parser, "expected %<,%> or %<}%>");
     c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL__null);
     values = error_mark_nodeglobal_trees[TI_ERROR_MARK];
     break;
   }
}
    postfix_attrs = c_parser_gnu_attributes (parser);
    ret.spec = finish_enum (type, nreverse (values),
	      chainon (std_attrs,
		       chainon (attrs, postfix_attrs)));
    ret.kind = ctsk_tagdef;
    ret.expr = NULL_TREE(tree) __null;
    ret.expr_const_operands = true;
    timevar_pop (TV_PARSE_ENUM);
    return ret;
  }
else if (!ident)
  {
    c_parser_error (parser, "expected %<{%>");
    ret.spec = error_mark_nodeglobal_trees[TI_ERROR_MARK];
    ret.kind = ctsk_tagref;
    ret.expr = NULL_TREE(tree) __null;
    ret.expr_const_operands = true;
    return ret;
  }
/* Attributes may only appear when the members are defined or in
   certain forward declarations (treat enum forward declarations in
   GNU C analogously to struct and union forward declarations in
   standard C).  */
if (have_std_attrs && c_parser_next_token_is_not (parser, CPP_SEMICOLON))
  c_parser_error (parser, "expected %<;%>");
ret = parser_xref_tag (ident_loc, ENUMERAL_TYPE, ident, have_std_attrs,
	 std_attrs);
/* In ISO C, enumerated types can be referred to only if already
   defined.  */
if (pedanticglobal_options.x_pedantic && !COMPLETE_TYPE_P (ret.spec)(((tree_class_check ((ret.spec), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3279, __FUNCTION__))->type_common.size) != (tree) __null
))
  {
    gcc_assert (ident)((void)(!(ident) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3281, __FUNCTION__), 0 : 0));
    pedwarn (enum_loc, OPT_Wpedantic,
      "ISO C forbids forward references to %<enum%> types");
  }
return ret;
3286}

3288/* Parse a struct or union specifier (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1).

 struct-or-union-specifier:
   struct-or-union attribute-specifier-sequence[opt] gnu-attributes[opt]
     identifier[opt] { struct-contents } gnu-attributes[opt]
   struct-or-union attribute-specifier-sequence[opt] gnu-attributes[opt]
     identifier

 struct-contents:
   struct-declaration-list

 struct-declaration-list:
   struct-declaration ;
   struct-declaration-list struct-declaration ;

 GNU extensions:

 struct-contents:
   empty
   struct-declaration
   struct-declaration-list struct-declaration

 struct-declaration-list:
   struct-declaration-list ;
   ;

 (Note that in the syntax here, unlike that in ISO C, the semicolons
 are included here rather than in struct-declaration, in order to
 describe the syntax with extra semicolons and missing semicolon at
 end.)

 Objective-C:

 struct-declaration-list:
   @defs ( class-name )

 (Note this does not include a trailing semicolon, but can be
 followed by further declarations, and gets a pedwarn-if-pedantic
 when followed by a semicolon.)  */

3328static struct c_typespec
3329c_parser_struct_or_union_specifier (c_parser *parser)
3330{
struct c_typespec ret;
bool have_std_attrs;
tree std_attrs = NULL_TREE(tree) __null;
tree attrs;
tree ident = NULL_TREE(tree) __null;
location_t struct_loc;
location_t ident_loc = UNKNOWN_LOCATION((location_t) 0);
enum tree_code code;
switch (c_parser_peek_token (parser)->keyword)
  {
  case RID_STRUCT:
    code = RECORD_TYPE;
    break;
  case RID_UNION:
    code = UNION_TYPE;
    break;
  default:
    gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3348, __FUNCTION__));
  }
struct_loc = c_parser_peek_token (parser)->location;
c_parser_consume_token (parser);
have_std_attrs = c_parser_nth_token_starts_std_attributes (parser, 1);
if (have_std_attrs)
  std_attrs = c_parser_std_attribute_specifier_sequence (parser);
attrs = c_parser_gnu_attributes (parser);

/* Set the location in case we create a decl now.  */
c_parser_set_source_position_from_token (c_parser_peek_token (parser));

if (c_parser_next_token_is (parser, CPP_NAME))
  {
    ident = c_parser_peek_token (parser)->value;
    ident_loc = c_parser_peek_token (parser)->location;
    struct_loc = ident_loc;
    c_parser_consume_token (parser);
  }
if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
  {
    /* Parse a struct or union definition.  Start the scope of the
tag before parsing components.  */
    class c_struct_parse_info *struct_info;
    tree type = start_struct (struct_loc, code, ident, &struct_info);
    tree postfix_attrs;
    /* We chain the components in reverse order, then put them in
forward order at the end.  Each struct-declaration may
declare multiple components (comma-separated), so we must use
chainon to join them, although when parsing each
struct-declaration we can use TREE_CHAIN directly.

The theory behind all this is that there will be more
semicolon separated fields than comma separated fields, and
so we'll be minimizing the number of node traversals required
by chainon.  */
    tree contents;
    timevar_push (TV_PARSE_STRUCT);
    contents = NULL_TREE(tree) __null;
    c_parser_consume_token (parser);
    /* Handle the Objective-C @defs construct,
e.g. foo(sizeof(struct{ @defs(ClassName) }));.  */
    if (c_parser_next_token_is_keyword (parser, RID_AT_DEFS))
{
 tree name;
 gcc_assert (c_dialect_objc ())((void)(!(((c_language & clk_objc) != 0)) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3393, __FUNCTION__), 0 : 0));
 c_parser_consume_token (parser);
 matching_parens parens;
 if (!parens.require_open (parser))
   goto end_at_defs;
 if (c_parser_next_token_is (parser, CPP_NAME)
     && c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME)
   {
     name = c_parser_peek_token (parser)->value;
     c_parser_consume_token (parser);
   }
 else
   {
     c_parser_error (parser, "expected class name");
     c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL__null);
     goto end_at_defs;
   }
 parens.skip_until_found_close (parser);
 contents = nreverse (objc_get_class_ivars (name));
}
  end_at_defs:
    /* Parse the struct-declarations and semicolons.  Problems with
semicolons are diagnosed here; empty structures are diagnosed
elsewhere.  */
    while (true)
{
 tree decls;
 /* Parse any stray semicolon.  */
 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
   {
     location_t semicolon_loc
= c_parser_peek_token (parser)->location;
     gcc_rich_location richloc (semicolon_loc);
     richloc.add_fixit_remove ();
     pedwarn (&richloc, OPT_Wpedantic,
       "extra semicolon in struct or union specified");
     c_parser_consume_token (parser);
     continue;
   }
 /* Stop if at the end of the struct or union contents.  */
 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
   {
     c_parser_consume_token (parser);
     break;
   }
 /* Accept #pragmas at struct scope.  */
 if (c_parser_next_token_is (parser, CPP_PRAGMA))
   {
     c_parser_pragma (parser, pragma_struct, NULL__null);
     continue;
   }
 /* Parse some comma-separated declarations, but not the
    trailing semicolon if any.  */
 decls = c_parser_struct_declaration (parser);
 contents = chainon (decls, contents);
 /* If no semicolon follows, either we have a parse error or
    are at the end of the struct or union and should
    pedwarn.  */
 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
   c_parser_consume_token (parser);
 else
   {
     if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
pedwarn (c_parser_peek_token (parser)->location, 0,
	 "no semicolon at end of struct or union");
     else if (parser->error
       || !c_parser_next_token_starts_declspecs (parser))
{
  c_parser_error (parser, "expected %<;%>");
  c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL__null);
  break;
}

     /* If we come here, we have already emitted an error
 for an expected `;', identifier or `(', and we also
        recovered already.  Go on with the next field. */
   }
}
    postfix_attrs = c_parser_gnu_attributes (parser);
    ret.spec = finish_struct (struct_loc, type, nreverse (contents),
		chainon (std_attrs,
			 chainon (attrs, postfix_attrs)),
		struct_info);
    ret.kind = ctsk_tagdef;
    ret.expr = NULL_TREE(tree) __null;
    ret.expr_const_operands = true;
    timevar_pop (TV_PARSE_STRUCT);
    return ret;
  }
else if (!ident)
  {
    c_parser_error (parser, "expected %<{%>");
    ret.spec = error_mark_nodeglobal_trees[TI_ERROR_MARK];
    ret.kind = ctsk_tagref;
    ret.expr = NULL_TREE(tree) __null;
    ret.expr_const_operands = true;
    return ret;
  }
/* Attributes may only appear when the members are defined or in
   certain forward declarations.  */
if (have_std_attrs && c_parser_next_token_is_not (parser, CPP_SEMICOLON))
  c_parser_error (parser, "expected %<;%>");
/* ??? Existing practice is that GNU attributes are ignored after
   the struct or union keyword when not defining the members.  */
ret = parser_xref_tag (ident_loc, code, ident, have_std_attrs, std_attrs);
return ret;
3499}

3501/* Parse a struct-declaration (C90 6.5.2.1, C99 6.7.2.1, C11 6.7.2.1),
 *without* the trailing semicolon.

 struct-declaration:
   attribute-specifier-sequence[opt] specifier-qualifier-list
     attribute-specifier-sequence[opt] struct-declarator-list
   static_assert-declaration-no-semi

 specifier-qualifier-list:
   type-specifier specifier-qualifier-list[opt]
   type-qualifier specifier-qualifier-list[opt]
   alignment-specifier specifier-qualifier-list[opt]
   gnu-attributes specifier-qualifier-list[opt]

 struct-declarator-list:
   struct-declarator
   struct-declarator-list , gnu-attributes[opt] struct-declarator

 struct-declarator:
   declarator gnu-attributes[opt]
   declarator[opt] : constant-expression gnu-attributes[opt]

 GNU extensions:

 struct-declaration:
   __extension__ struct-declaration
   specifier-qualifier-list

 Unlike the ISO C syntax, semicolons are handled elsewhere.  The use
 of gnu-attributes where shown is a GNU extension.  In GNU C, we accept
 any expression without commas in the syntax (assignment
 expressions, not just conditional expressions); assignment
 expressions will be diagnosed as non-constant.  */

3535static tree
3536c_parser_struct_declaration (c_parser *parser)
3537{
struct c_declspecs *specs;
tree prefix_attrs;
tree all_prefix_attrs;
tree decls;
location_t decl_loc;
if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
  {
    int ext;
    tree decl;
    ext = disable_extension_diagnostics ();
    c_parser_consume_token (parser);
    decl = c_parser_struct_declaration (parser);
    restore_extension_diagnostics (ext);
    return decl;
  }
if (c_parser_next_token_is_keyword (parser, RID_STATIC_ASSERT))
  {
    c_parser_static_assert_declaration_no_semi (parser);
    return NULL_TREE(tree) __null;
  }
specs = build_null_declspecs ();
decl_loc = c_parser_peek_token (parser)->location;
/* Strictly by the standard, we shouldn't allow _Alignas here,
   but it appears to have been intended to allow it there, so
   we're keeping it as it is until WG14 reaches a conclusion
   of N1731.
   <http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1731.pdf>  */
c_parser_declspecs (parser, specs, false, true, true,
      true, false, true, true, cla_nonabstract_decl);
if (parser->error)
  return NULL_TREE(tree) __null;
if (!specs->declspecs_seen_p)
  {
    c_parser_error (parser, "expected specifier-qualifier-list");
    return NULL_TREE(tree) __null;
  }
finish_declspecs (specs);
if (c_parser_next_token_is (parser, CPP_SEMICOLON)
    || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
  {
    tree ret;
    if (specs->typespec_kind == ctsk_none)
{
 pedwarn (decl_loc, OPT_Wpedantic,
   "ISO C forbids member declarations with no members");
 shadow_tag_warned (specs, pedanticglobal_options.x_pedantic);
 ret = NULL_TREE(tree) __null;
}
    else
{
 /* Support for unnamed structs or unions as members of
    structs or unions (which is [a] useful and [b] supports
    MS P-SDK).  */
 tree attrs = NULL__null;

 ret = grokfield (c_parser_peek_token (parser)->location,
	   build_id_declarator (NULL_TREE(tree) __null), specs,
	   NULL_TREE(tree) __null, &attrs);
 if (ret)
   decl_attributes (&ret, attrs, 0);
}
    return ret;
  }

/* Provide better error recovery.  Note that a type name here is valid,
   and will be treated as a field name.  */
if (specs->typespec_kind == ctsk_tagdef
    && TREE_CODE (specs->type)((enum tree_code) (specs->type)->base.code) != ENUMERAL_TYPE
    && c_parser_next_token_starts_declspecs (parser)
    && !c_parser_next_token_is (parser, CPP_NAME))
  {
    c_parser_error (parser, "expected %<;%>, identifier or %<(%>");
    parser->error = false;
    return NULL_TREE(tree) __null;
  }

pending_xref_error ();
prefix_attrs = specs->attrs;
all_prefix_attrs = prefix_attrs;
specs->attrs = NULL_TREE(tree) __null;
decls = NULL_TREE(tree) __null;
while (true)
  {
    /* Declaring one or more declarators or un-named bit-fields.  */
    struct c_declarator *declarator;
    bool dummy = false;
    if (c_parser_next_token_is (parser, CPP_COLON))
declarator = build_id_declarator (NULL_TREE(tree) __null);
    else
declarator = c_parser_declarator (parser,
			  specs->typespec_kind != ctsk_none,
			  C_DTR_NORMAL, &dummy);
    if (declarator == NULL__null)
{
 c_parser_skip_to_end_of_block_or_statement (parser);
 break;
}
    if (c_parser_next_token_is (parser, CPP_COLON)
 || c_parser_next_token_is (parser, CPP_COMMA)
 || c_parser_next_token_is (parser, CPP_SEMICOLON)
 || c_parser_next_token_is (parser, CPP_CLOSE_BRACE)
 || c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
{
 tree postfix_attrs = NULL_TREE(tree) __null;
 tree width = NULL_TREE(tree) __null;
 tree d;
 if (c_parser_next_token_is (parser, CPP_COLON))
   {
     c_parser_consume_token (parser);
     width = c_parser_expr_no_commas (parser, NULL__null).value;
   }
 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
   postfix_attrs = c_parser_gnu_attributes (parser);
 d = grokfield (c_parser_peek_token (parser)->location,
	 declarator, specs, width, &all_prefix_attrs);
 decl_attributes (&d, chainon (postfix_attrs,
			all_prefix_attrs), 0);
 DECL_CHAIN (d)(((contains_struct_check (((contains_struct_check ((d), (TS_DECL_MINIMAL
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3655, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3655, __FUNCTION__))->common.chain)) = decls;
 decls = d;
 if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
   all_prefix_attrs = chainon (c_parser_gnu_attributes (parser),
			prefix_attrs);
 else
   all_prefix_attrs = prefix_attrs;
 if (c_parser_next_token_is (parser, CPP_COMMA))
   c_parser_consume_token (parser);
 else if (c_parser_next_token_is (parser, CPP_SEMICOLON)
   || c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
   {
     /* Semicolon consumed in caller.  */
     break;
   }
 else
   {
     c_parser_error (parser, "expected %<,%>, %<;%> or %<}%>");
     break;
   }
}
    else
{
 c_parser_error (parser,
	  "expected %<:%>, %<,%>, %<;%>, %<}%> or "
	  "%<__attribute__%>");
 break;
}
  }
return decls;
3685}

3687/* Parse a typeof specifier (a GNU extension).

 typeof-specifier:
   typeof ( expression )
   typeof ( type-name )
3692*/

3694static struct c_typespec
3695c_parser_typeof_specifier (c_parser *parser)
3696{
struct c_typespec ret;
ret.kind = ctsk_typeof;
ret.spec = error_mark_nodeglobal_trees[TI_ERROR_MARK];
ret.expr = NULL_TREE(tree) __null;
ret.expr_const_operands = true;
gcc_assert (c_parser_next_token_is_keyword (parser, RID_TYPEOF))((void)(!(c_parser_next_token_is_keyword (parser, RID_TYPEOF)
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3702, __FUNCTION__), 0 : 0));
c_parser_consume_token (parser);
c_inhibit_evaluation_warnings++;
in_typeof++;
matching_parens parens;
if (!parens.require_open (parser))
  {
    c_inhibit_evaluation_warnings--;
    in_typeof--;
    return ret;
  }
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--;
    in_typeof--;
    if (type != NULL__null)
{
 ret.spec = groktypename (type, &ret.expr, &ret.expr_const_operands);
 pop_maybe_used (variably_modified_type_p (ret.spec, NULL_TREE(tree) __null));
}
  }
else
  {
    bool was_vm;
    location_t here = c_parser_peek_token (parser)->location;
    struct c_expr expr = c_parser_expression (parser);
    c_inhibit_evaluation_warnings--;
    in_typeof--;
    if (TREE_CODE (expr.value)((enum tree_code) (expr.value)->base.code) == COMPONENT_REF
 && DECL_C_BIT_FIELD (TREE_OPERAND (expr.value, 1))(((contains_struct_check (((tree_check (((*((const_cast<tree
*> (tree_operand_check ((expr.value), (1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3732, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3732, __FUNCTION__, (FIELD_DECL)))), (TS_DECL_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3732, __FUNCTION__))->decl_common.lang_flag_4) == 1))
error_at (here, "%<typeof%> applied to a bit-field");
    mark_exp_read (expr.value);
    ret.spec = TREE_TYPE (expr.value)((contains_struct_check ((expr.value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3735, __FUNCTION__))->typed.type);
    was_vm = variably_modified_type_p (ret.spec, NULL_TREE(tree) __null);
    /* This is returned with the type so that when the type is
evaluated, this can be evaluated.  */
    if (was_vm)
ret.expr = c_fully_fold (expr.value, false, &ret.expr_const_operands);
    pop_maybe_used (was_vm);
  }
parens.skip_until_found_close (parser);
return ret;
3745}

3747/* Parse an alignment-specifier.

 C11 6.7.5:

 alignment-specifier:
   _Alignas ( type-name )
   _Alignas ( constant-expression )
3754*/

3756static tree
3757c_parser_alignas_specifier (c_parser * parser)
3758{
tree ret = error_mark_nodeglobal_trees[TI_ERROR_MARK];
location_t loc = c_parser_peek_token (parser)->location;
gcc_assert (c_parser_next_token_is_keyword (parser, RID_ALIGNAS))((void)(!(c_parser_next_token_is_keyword (parser, RID_ALIGNAS
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3761, __FUNCTION__), 0 : 0));
c_parser_consume_token (parser);
if (flag_isoc99)
  pedwarn_c99 (loc, OPT_Wpedantic,
 "ISO C99 does not support %<_Alignas%>");
else
  pedwarn_c99 (loc, OPT_Wpedantic,
 "ISO C90 does not support %<_Alignas%>");
matching_parens parens;
if (!parens.require_open (parser))
  return ret;
if (c_parser_next_tokens_start_typename (parser, cla_prefer_id))
  {
    struct c_type_name *type = c_parser_type_name (parser);
    if (type != NULL__null)
ret = c_sizeof_or_alignof_type (loc, groktypename (type, NULL__null, NULL__null),
			false, true, 1);
  }
else
  ret = c_parser_expr_no_commas (parser, NULL__null).value;
parens.skip_until_found_close (parser);
return ret;
3783}

3785/* Parse a declarator, possibly an abstract declarator (C90 6.5.4,
 6.5.5, C99 6.7.5, 6.7.6, C11 6.7.6, 6.7.7).  If TYPE_SEEN_P then
 a typedef name may be redeclared; otherwise it may not.  KIND
 indicates which kind of declarator is wanted.  Returns a valid
 declarator except in the case of a syntax error in which case NULL is
 returned.  *SEEN_ID is set to true if an identifier being declared is
 seen; this is used to diagnose bad forms of abstract array declarators
 and to determine whether an identifier list is syntactically permitted.

 declarator:
   pointer[opt] direct-declarator

 direct-declarator:
   identifier
   ( gnu-attributes[opt] declarator )
   direct-declarator array-declarator
   direct-declarator ( parameter-type-list )
   direct-declarator ( identifier-list[opt] )

 pointer:
   * type-qualifier-list[opt]
   * type-qualifier-list[opt] pointer

 type-qualifier-list:
   type-qualifier
   gnu-attributes
   type-qualifier-list type-qualifier
   type-qualifier-list gnu-attributes

 array-declarator:
   [ type-qualifier-list[opt] assignment-expression[opt] ]
   [ static type-qualifier-list[opt] assignment-expression ]
   [ type-qualifier-list static assignment-expression ]
   [ type-qualifier-list[opt] * ]

 parameter-type-list:
   parameter-list
   parameter-list , ...

 parameter-list:
   parameter-declaration
   parameter-list , parameter-declaration

 parameter-declaration:
   declaration-specifiers declarator gnu-attributes[opt]
   declaration-specifiers abstract-declarator[opt] gnu-attributes[opt]

 identifier-list:
   identifier
   identifier-list , identifier

 abstract-declarator:
   pointer
   pointer[opt] direct-abstract-declarator

 direct-abstract-declarator:
   ( gnu-attributes[opt] abstract-declarator )
   direct-abstract-declarator[opt] array-declarator
   direct-abstract-declarator[opt] ( parameter-type-list[opt] )

 GNU extensions:

 direct-declarator:
   direct-declarator ( parameter-forward-declarations
	 parameter-type-list[opt] )

 direct-abstract-declarator:
   direct-abstract-declarator[opt] ( parameter-forward-declarations
		       parameter-type-list[opt] )

 parameter-forward-declarations:
   parameter-list ;
   parameter-forward-declarations parameter-list ;

 The uses of gnu-attributes shown above are GNU extensions.

 Some forms of array declarator are not included in C99 in the
 syntax for abstract declarators; these are disallowed elsewhere.
 This may be a defect (DR#289).

 This function also accepts an omitted abstract declarator as being
 an abstract declarator, although not part of the formal syntax.  */

3868struct c_declarator *
3869c_parser_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
     bool *seen_id)
3871{
/* Parse any initial pointer part.  */
if (c_parser_next_token_is (parser, CPP_MULT))
  {
    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,
	  false, false, true, false, cla_prefer_id);
    inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
    if (inner == NULL__null)
return NULL__null;
    else
return make_pointer_declarator (quals_attrs, inner);
  }
/* Now we have a direct declarator, direct abstract declarator or
   nothing (which counts as a direct abstract declarator here).  */
return c_parser_direct_declarator (parser, type_seen_p, kind, seen_id);
3889}

3891/* Parse a direct declarator or direct abstract declarator; arguments
 as c_parser_declarator.  */

3894static struct c_declarator *
3895c_parser_direct_declarator (c_parser *parser, bool type_seen_p, c_dtr_syn kind,
	    bool *seen_id)
3897{
/* The direct declarator must start with an identifier (possibly
   omitted) or a parenthesized declarator (possibly abstract).  In
   an ordinary declarator, initial parentheses must start a
   parenthesized declarator.  In an abstract declarator or parameter
   declarator, they could start a parenthesized declarator or a
   parameter list.  To tell which, the open parenthesis and any
   following gnu-attributes must be read.  If a declaration
   specifier or standard attributes follow, then it is a parameter
   list; if the specifier is a typedef name, there might be an
   ambiguity about redeclaring it, which is resolved in the
   direction of treating it as a typedef name.  If a close
   parenthesis follows, it is also an empty parameter list, as the
   syntax does not permit empty abstract declarators.  Otherwise, it
   is a parenthesized declarator (in which case the analysis may be
   repeated inside it, recursively).

   ??? There is an ambiguity in a parameter declaration "int
   (__attribute__((foo)) x)", where x is not a typedef name: it
   could be an abstract declarator for a function, or declare x with
   parentheses.  The proper resolution of this ambiguity needs
   documenting.  At present we follow an accident of the old
   parser's implementation, whereby the first parameter must have
   some declaration specifiers other than just gnu-attributes.  Thus as
   a parameter declaration it is treated as a parenthesized
   parameter named x, and as an abstract declarator it is
   rejected.

   ??? Also following the old parser, gnu-attributes inside an empty
   parameter list are ignored, making it a list not yielding a
   prototype, rather than giving an error or making it have one
   parameter with implicit type int.

   ??? Also following the old parser, typedef names may be
   redeclared in declarators, but not Objective-C class names.  */

if (kind != C_DTR_ABSTRACT
    && c_parser_next_token_is (parser, CPP_NAME)
    && ((type_seen_p
  && (c_parser_peek_token (parser)->id_kind == C_ID_TYPENAME
      || c_parser_peek_token (parser)->id_kind == C_ID_CLASSNAME))
 || c_parser_peek_token (parser)->id_kind == C_ID_ID))
  {
    struct c_declarator *inner
= build_id_declarator (c_parser_peek_token (parser)->value);
    *seen_id = true;
    inner->id_loc = c_parser_peek_token (parser)->location;
    c_parser_consume_token (parser);
    if (c_parser_nth_token_starts_std_attributes (parser, 1))
inner->u.id.attrs = c_parser_std_attribute_specifier_sequence (parser);
    return c_parser_direct_declarator_inner (parser, *seen_id, inner);
  }

if (kind != C_DTR_NORMAL
    && c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
    && !c_parser_nth_token_starts_std_attributes (parser, 1))
  {
    struct c_declarator *inner = build_id_declarator (NULL_TREE(tree) __null);
    inner->id_loc = c_parser_peek_token (parser)->location;
    return c_parser_direct_declarator_inner (parser, *seen_id, inner);
  }

/* Either we are at the end of an abstract declarator, or we have
   parentheses.  */

if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
  {
    tree attrs;
    struct c_declarator *inner;
    c_parser_consume_token (parser);
    bool have_gnu_attrs = c_parser_next_token_is_keyword (parser,
					    RID_ATTRIBUTE);
    attrs = c_parser_gnu_attributes (parser);
    if (kind != C_DTR_NORMAL
 && (c_parser_next_token_starts_declspecs (parser)
     || (!have_gnu_attrs
  && c_parser_nth_token_starts_std_attributes (parser, 1))
     || c_parser_next_token_is (parser, CPP_CLOSE_PAREN)))
{
 struct c_arg_info *args
   = c_parser_parms_declarator (parser, kind == C_DTR_NORMAL,
			 attrs, have_gnu_attrs);
 if (args == NULL__null)
   return NULL__null;
 else
   {
     inner = build_id_declarator (NULL_TREE(tree) __null);
     if (!(args->types
    && args->types != error_mark_nodeglobal_trees[TI_ERROR_MARK]
    && TREE_CODE (TREE_VALUE (args->types))((enum tree_code) (((tree_check ((args->types), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 3986, __FUNCTION__, (TREE_LIST)))->list.value))->base
.code) == IDENTIFIER_NODE)
  && c_parser_nth_token_starts_std_attributes (parser, 1))
{
  tree std_attrs
    = c_parser_std_attribute_specifier_sequence (parser);
  if (std_attrs)
    inner = build_attrs_declarator (std_attrs, inner);
}
     inner = build_function_declarator (args, inner);
     return c_parser_direct_declarator_inner (parser, *seen_id,
				       inner);
   }
}
    /* A parenthesized declarator.  */
    inner = c_parser_declarator (parser, type_seen_p, kind, seen_id);
    if (inner != NULL__null && attrs != NULL__null)
inner = build_attrs_declarator (attrs, inner);
    if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
{
 c_parser_consume_token (parser);
 if (inner == NULL__null)
   return NULL__null;
 else
   return c_parser_direct_declarator_inner (parser, *seen_id, inner);
}
    else
{
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
		     "expected %<)%>");
 return NULL__null;
}
  }
else
  {
    if (kind == C_DTR_NORMAL)
{
 c_parser_error (parser, "expected identifier or %<(%>");
 return NULL__null;
}
    else
return build_id_declarator (NULL_TREE(tree) __null);
  }
4028}

4030/* Parse part of a direct declarator or direct abstract declarator,
 given that some (in INNER) has already been parsed; ID_PRESENT is
 true if an identifier is present, false for an abstract
 declarator.  */

4035static struct c_declarator *
4036c_parser_direct_declarator_inner (c_parser *parser, bool id_present,
		  struct c_declarator *inner)
4038{
/* Parse a sequence of array declarators and parameter lists.  */
if (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
    && !c_parser_nth_token_starts_std_attributes (parser, 1))
  {
    location_t brace_loc = c_parser_peek_token (parser)->location;
    struct c_declarator *declarator;
    struct c_declspecs *quals_attrs = build_null_declspecs ();
    bool static_seen;
    bool star_seen;
    struct c_expr dimen;
    dimen.value = NULL_TREE(tree) __null;
    dimen.original_code = ERROR_MARK;
    dimen.original_type = NULL_TREE(tree) __null;
    c_parser_consume_token (parser);
    c_parser_declspecs (parser, quals_attrs, false, false, true,
	  false, false, false, false, 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,
	    false, false, false, false, cla_prefer_id);
    if (!quals_attrs->declspecs_seen_p)
quals_attrs = NULL__null;
    /* If "static" is present, there must be an array dimension.
Otherwise, there may be a dimension, "*", or no
dimension.  */
    if (static_seen)
{
 star_seen = false;
 dimen = c_parser_expr_no_commas (parser, NULL__null);
}
    else
{
 if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
   {
     dimen.value = NULL_TREE(tree) __null;
     star_seen = false;
   }
 else if (c_parser_next_token_is (parser, CPP_MULT))
   {
     if (c_parser_peek_2nd_token (parser)->type == CPP_CLOSE_SQUARE)
{
  dimen.value = NULL_TREE(tree) __null;
  star_seen = true;
  c_parser_consume_token (parser);
}
     else
{
  star_seen = false;
  dimen = c_parser_expr_no_commas (parser, NULL__null);
}
   }
 else
   {
     star_seen = false;
     dimen = c_parser_expr_no_commas (parser, NULL__null);
   }
}
    if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
c_parser_consume_token (parser);
    else
{
 c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
		     "expected %<]%>");
 return NULL__null;
}
    if (dimen.value)
dimen = convert_lvalue_to_rvalue (brace_loc, dimen, true, true);
    declarator = build_array_declarator (brace_loc, dimen.value, quals_attrs,
			   static_seen, star_seen);
    if (declarator == NULL__null)
return NULL__null;
    if (c_parser_nth_token_starts_std_attributes (parser, 1))
{
 tree std_attrs
   = c_parser_std_attribute_specifier_sequence (parser);
 if (std_attrs)
   inner = build_attrs_declarator (std_attrs, inner);
}
    inner = set_array_declarator_inner (declarator, inner);
    return c_parser_direct_declarator_inner (parser, id_present, inner);
  }
else if (c_parser_next_token_is (parser, CPP_OPEN_PAREN))
  {
    tree attrs;
    struct c_arg_info *args;
    c_parser_consume_token (parser);
    bool have_gnu_attrs = c_parser_next_token_is_keyword (parser,
					    RID_ATTRIBUTE);
    attrs = c_parser_gnu_attributes (parser);
    args = c_parser_parms_declarator (parser, id_present, attrs,
			have_gnu_attrs);
    if (args == NULL__null)
return NULL__null;
    else
{
 if (!(args->types
&& args->types != error_mark_nodeglobal_trees[TI_ERROR_MARK]
&& TREE_CODE (TREE_VALUE (args->types))((enum tree_code) (((tree_check ((args->types), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 4138, __FUNCTION__, (TREE_LIST)))->list.value))->base
.code) == IDENTIFIER_NODE)
     && c_parser_nth_token_starts_std_attributes (parser, 1))
   {
     tree std_attrs
= c_parser_std_attribute_specifier_sequence (parser);
     if (std_attrs)
inner = build_attrs_declarator (std_attrs, inner);
   }
 inner = build_function_declarator (args, inner);
 return c_parser_direct_declarator_inner (parser, id_present, inner);
}
  }
return inner;
4151}

4153/* Parse a parameter list or identifier list, including the closing
 parenthesis but not the opening one.  ATTRS are the gnu-attributes
 at the start of the list.  ID_LIST_OK is true if an identifier list
 is acceptable; such a list must not have attributes at the start.
 HAVE_GNU_ATTRS says whether any gnu-attributes (including empty
 attributes) were present (in which case standard attributes cannot
 occur).  */

4161static struct c_arg_info *
4162c_parser_parms_declarator (c_parser *parser, bool id_list_ok, tree attrs,
	   bool have_gnu_attrs)
4164{
push_scope ();
declare_parm_level ();
/* If the list starts with an identifier, it is an identifier list.
   Otherwise, it is either a prototype list or an empty list.  */
if (id_list_ok
    && !attrs
    && c_parser_next_token_is (parser, CPP_NAME)
    && 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
    && c_parser_peek_2nd_token (parser)->type != CPP_KEYWORD)
  {
    tree list = NULL_TREE(tree) __null, *nextp = &list;
    while (c_parser_next_token_is (parser, CPP_NAME)
    && c_parser_peek_token (parser)->id_kind == C_ID_ID)
{
 *nextp = build_tree_list (NULL_TREE(tree) __null,
		    c_parser_peek_token (parser)->value);
 nextp = & TREE_CHAIN (*nextp)((contains_struct_check ((*nextp), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 4187, __FUNCTION__))->common.chain);
 c_parser_consume_token (parser);
 if (c_parser_next_token_is_not (parser, CPP_COMMA))
   break;
 c_parser_consume_token (parser);
 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
   {
     c_parser_error (parser, "expected identifier");
     break;
   }
}
    if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
{
 struct c_arg_info *ret = build_arg_info ();
 ret->types = list;
 c_parser_consume_token (parser);
 pop_scope ();
 return ret;
}
    else
{
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
		     "expected %<)%>");
 pop_scope ();
 return NULL__null;
}
  }
else
  {
    struct c_arg_info *ret
= c_parser_parms_list_declarator (parser, attrs, NULL__null, have_gnu_attrs);
    pop_scope ();
    return ret;
  }
4221}

4223/* Parse a parameter list (possibly empty), including the closing
 parenthesis but not the opening one.  ATTRS are the gnu-attributes
 at the start of the list; if HAVE_GNU_ATTRS, there were some such
 attributes (possibly empty, in which case ATTRS is NULL_TREE),
 which means standard attributes cannot start the list.  EXPR is
 NULL or an expression that needs to be evaluated for the side
 effects of array size expressions in the parameters.  */

4231static struct c_arg_info *
4232c_parser_parms_list_declarator (c_parser *parser, tree attrs, tree expr,
		bool have_gnu_attrs)
4234{
bool bad_parm = false;

/* ??? Following the old parser, forward parameter declarations may
   use abstract declarators, and if no real parameter declarations
   follow the forward declarations then this is not diagnosed.  Also
   note as above that gnu-attributes are ignored as the only contents of
   the parentheses, or as the only contents after forward
   declarations.  */
if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
  {
    struct c_arg_info *ret = build_arg_info ();
    c_parser_consume_token (parser);
    return ret;
  }
if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
  {
    struct c_arg_info *ret = build_arg_info ();

    if (flag_allow_parameterless_variadic_functionsglobal_options.x_flag_allow_parameterless_variadic_functions)
      {
        /* F (...) is allowed.  */
        ret->types = NULL_TREE(tree) __null;
      }
    else
      {
        /* Suppress -Wold-style-definition for this case.  */
        ret->types = error_mark_nodeglobal_trees[TI_ERROR_MARK];
        error_at (c_parser_peek_token (parser)->location,
                  "ISO C requires a named argument before %<...%>");
      }
    c_parser_consume_token (parser);
    if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
{
 c_parser_consume_token (parser);
 return ret;
}
    else
{
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
		     "expected %<)%>");
 return NULL__null;
}
  }
/* Nonempty list of parameters, either terminated with semicolon
   (forward declarations; recurse) or with close parenthesis (normal
   function) or with ", ... )" (variadic function).  */
while (true)
  {
    /* Parse a parameter.  */
    struct c_parm *parm = c_parser_parameter_declaration (parser, attrs,
					    have_gnu_attrs);
    attrs = NULL_TREE(tree) __null;
    have_gnu_attrs = false;
    if (parm == NULL__null)
bad_parm = true;
    else
push_parm_decl (parm, &expr);
    if (c_parser_next_token_is (parser, CPP_SEMICOLON))
{
 tree new_attrs;
 c_parser_consume_token (parser);
 mark_forward_parm_decls ();
 bool new_have_gnu_attrs
   = c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE);
 new_attrs = c_parser_gnu_attributes (parser);
 return c_parser_parms_list_declarator (parser, new_attrs, expr,
				 new_have_gnu_attrs);
}
    if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
{
 c_parser_consume_token (parser);
 if (bad_parm)
   return NULL__null;
 else
   return get_parm_info (false, expr);
}
    if (!c_parser_require (parser, CPP_COMMA,
	     "expected %<;%>, %<,%> or %<)%>",
	     UNKNOWN_LOCATION((location_t) 0), false))
{
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL__null);
 return NULL__null;
}
    if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
{
 c_parser_consume_token (parser);
 if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
   {
     c_parser_consume_token (parser);
     if (bad_parm)
return NULL__null;
     else
return get_parm_info (true, expr);
   }
 else
   {
     c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
			 "expected %<)%>");
     return NULL__null;
   }
}
  }
4337}

4339/* Parse a parameter declaration.  ATTRS are the gnu-attributes at the
 start of the declaration if it is the first parameter;
 HAVE_GNU_ATTRS is true if there were any gnu-attributes there (even
 empty) there.  */

4344static struct c_parm *
4345c_parser_parameter_declaration (c_parser *parser, tree attrs,
		bool have_gnu_attrs)
4347{
struct c_declspecs *specs;
struct c_declarator *declarator;
tree prefix_attrs;
tree postfix_attrs = NULL_TREE(tree) __null;
bool dummy = false;

/* Accept #pragmas between parameter declarations.  */
while (c_parser_next_token_is (parser, CPP_PRAGMA))
  c_parser_pragma (parser, pragma_param, NULL__null);

if (!c_parser_next_token_starts_declspecs (parser)
    && !c_parser_nth_token_starts_std_attributes (parser, 1))
  {
    c_token *token = c_parser_peek_token (parser);
    if (parser->error)
return NULL__null;
    c_parser_set_source_position_from_token (token);
    if (c_parser_next_tokens_start_typename (parser, cla_prefer_type))
{
 auto_diagnostic_group d;
 name_hint hint = lookup_name_fuzzy (token->value,
			      FUZZY_LOOKUP_TYPENAME,
			      token->location);
 if (const char *suggestion = hint.suggestion ())
   {
     gcc_rich_location richloc (token->location);
     richloc.add_fixit_replace (suggestion);
     error_at (&richloc,
	"unknown type name %qE; did you mean %qs?",
	token->value, suggestion);
   }
 else
   error_at (token->location, "unknown type name %qE", token->value);
 parser->error = true;
}
    /* ??? In some Objective-C cases '...' isn't applicable so there
should be a different message.  */
    else
c_parser_error (parser,
	"expected declaration specifiers or %<...%>");
    c_parser_skip_to_end_of_parameter (parser);
    return NULL__null;
  }

location_t start_loc = c_parser_peek_token (parser)->location;

specs = build_null_declspecs ();
if (attrs)
  {
    declspecs_add_attrs (input_location, specs, attrs);
    attrs = NULL_TREE(tree) __null;
  }
c_parser_declspecs (parser, specs, true, true, true, true, false,
      !have_gnu_attrs, true, cla_nonabstract_decl);
finish_declspecs (specs);
pending_xref_error ();
prefix_attrs = specs->attrs;
specs->attrs = NULL_TREE(tree) __null;
declarator = c_parser_declarator (parser,
		    specs->typespec_kind != ctsk_none,
		    C_DTR_PARM, &dummy);
if (declarator == NULL__null)
  {
    c_parser_skip_until_found (parser, CPP_COMMA, NULL__null);
    return NULL__null;
  }
if (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
  postfix_attrs = c_parser_gnu_attributes (parser);

/* Generate a location for the parameter, ranging from the start of the
   initial token to the end of the final token.

   If we have a identifier, then use it for the caret location, e.g.

     extern int callee (int one, int (*two)(int, int), float three);
                                 ~~~~~~^~~~~~~~~~~~~~

   otherwise, reuse the start location for the caret location e.g.:

     extern int callee (int one, int (*)(int, int), float three);
                                 ^~~~~~~~~~~~~~~~~
*/
location_t end_loc = parser->last_token_location;

/* Find any cdk_id declarator; determine if we have an identifier.  */
c_declarator *id_declarator = declarator;
while (id_declarator && id_declarator->kind != cdk_id)
  id_declarator = id_declarator->declarator;
location_t caret_loc = (id_declarator->u.id.id
	  ? id_declarator->id_loc
	  : start_loc);
location_t param_loc = make_location (caret_loc, start_loc, end_loc);

return build_c_parm (specs, chainon (postfix_attrs, prefix_attrs),
       declarator, param_loc);
4443}

4445/* Parse a string literal in an asm expression.  It should not be
 translated, and wide string literals are an error although
 permitted by the syntax.  This is a GNU extension.

 asm-string-literal:
   string-literal
4451*/

4453static tree
4454c_parser_asm_string_literal (c_parser *parser)
4455{
tree str;
int save_flag = warn_overlength_stringsglobal_options.x_warn_overlength_strings;
warn_overlength_stringsglobal_options.x_warn_overlength_strings = 0;
str = c_parser_string_literal (parser, false, false).value;
warn_overlength_stringsglobal_options.x_warn_overlength_strings = save_flag;
return str;
4462}

4464/* Parse a simple asm expression.  This is used in restricted
 contexts, where a full expression with inputs and outputs does not
 make sense.  This is a GNU extension.

 simple-asm-expr:
   asm ( asm-string-literal )
4470*/

4472static tree
4473c_parser_simple_asm_expr (c_parser *parser)
4474{
tree str;
gcc_assert (c_parser_next_token_is_keyword (parser, RID_ASM))((void)(!(c_parser_next_token_is_keyword (parser, RID_ASM)) ?
 fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 4476, __FUNCTION__), 0 : 0));
c_parser_consume_token (parser);
matching_parens parens;
if (!parens.require_open (parser))
  return NULL_TREE(tree) __null;
str = c_parser_asm_string_literal (parser);
if (!parens.require_close (parser))
  {
    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL__null);
    return NULL_TREE(tree) __null;
  }
return str;
4488}

4490static tree
4491c_parser_gnu_attribute_any_word (c_parser *parser)
4492{
tree attr_name = NULL_TREE(tree) __null;

if (c_parser_next_token_is (parser, CPP_KEYWORD))
  {
    /* ??? See comment above about what keywords are accepted here.  */
    bool ok;
    switch (c_parser_peek_token (parser)->keyword)
{
case RID_STATIC:
case RID_UNSIGNED:
case RID_LONG:
case RID_CONST:
case RID_EXTERN:
case RID_REGISTER:
case RID_TYPEDEF:
case RID_SHORT:
case RID_INLINE:
case RID_NORETURN:
case RID_VOLATILE:
case RID_SIGNED:
case RID_AUTO:
case RID_RESTRICT:
case RID_COMPLEX:
case RID_THREAD:
case RID_INT:
case RID_CHAR:
case RID_FLOAT:
case RID_DOUBLE:
case RID_VOID:
case RID_DFLOAT32:
case RID_DFLOAT64:
case RID_DFLOAT128:
CASE_RID_FLOATN_NXcase RID_FLOAT16: case RID_FLOAT32: case RID_FLOAT64: case RID_FLOAT128
: case RID_FLOAT32X: case RID_FLOAT64X: case RID_FLOAT128X:
case RID_BOOL:
case RID_FRACT:
case RID_ACCUM:
case RID_SAT:
case RID_TRANSACTION_ATOMIC:
case RID_TRANSACTION_CANCEL:
case RID_ATOMIC:
case RID_AUTO_TYPE:
case RID_INT_N_0:
case RID_INT_N_1:
case RID_INT_N_2:
case RID_INT_N_3:
 ok = true;
 break;
default:
 ok = false;
 break;
}
    if (!ok)
return NULL_TREE(tree) __null;

    /* Accept __attribute__((__const)) as __attribute__((const)) etc.  */
    attr_name = ridpointers[(int) c_parser_peek_token (parser)->keyword];
  }
else if (c_parser_next_token_is (parser, CPP_NAME))
  attr_name = c_parser_peek_token (parser)->value;

return attr_name;
4554}

4556/* Parse attribute arguments.  This is a common form of syntax
 covering all currently valid GNU and standard attributes.

 gnu-attribute-arguments:
   identifier
   identifier , nonempty-expr-list
   expr-list

 where the "identifier" must not be declared as a type.  ??? Why not
 allow identifiers declared as types to start the arguments?  */

4567static tree
4568c_parser_attribute_arguments (c_parser *parser, bool takes_identifier,
	      bool require_string, bool allow_empty_args)
4570{
vec<tree, va_gc> *expr_list;
tree attr_args;
/* Parse the attribute contents.  If they start with an
   identifier which is followed by a comma or close
   parenthesis, then the arguments start with that
   identifier; otherwise they are an expression list.
   In objective-c the identifier may be a classname.  */
if (c_parser_next_token_is (parser, CPP_NAME)
    && (c_parser_peek_token (parser)->id_kind == C_ID_ID
 || (c_dialect_objc ()((c_language & clk_objc) != 0)
     && c_parser_peek_token (parser)->id_kind
     == C_ID_CLASSNAME))
    && ((c_parser_peek_2nd_token (parser)->type == CPP_COMMA)
 || (c_parser_peek_2nd_token (parser)->type
     == CPP_CLOSE_PAREN))
    && (takes_identifier
 || (c_dialect_objc ()((c_language & clk_objc) != 0)
     && c_parser_peek_token (parser)->id_kind
     == C_ID_CLASSNAME)))
  {
    tree arg1 = c_parser_peek_token (parser)->value;
    c_parser_consume_token (parser);
    if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
attr_args = build_tree_list (NULL_TREE(tree) __null, arg1);
    else
{
 tree tree_list;
 c_parser_consume_token (parser);
 expr_list = c_parser_expr_list (parser, false, true,
			  NULL__null, NULL__null, NULL__null, NULL__null);
 tree_list = build_tree_list_vec (expr_list);
 attr_args = tree_cons (NULL_TREE(tree) __null, arg1, tree_list);
 release_tree_vector (expr_list);
}
  }
else
  {
    if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
{
 if (!allow_empty_args)
   error_at (c_parser_peek_token (parser)->location,
      "parentheses must be omitted if "
      "attribute argument list is empty");
 attr_args = NULL_TREE(tree) __null;
}
    else if (require_string)
{
 /* The only valid argument for this attribute is a string
    literal.  Handle this specially here to avoid accepting
    string literals with excess parentheses.  */
 tree string = c_parser_string_literal (parser, false, true).value;
 attr_args = build_tree_list (NULL_TREE(tree) __null, string);
}
    else
{
 expr_list = c_parser_expr_list (parser, false, true,
			  NULL__null, NULL__null, NULL__null, NULL__null);
 attr_args = build_tree_list_vec (expr_list);
 release_tree_vector (expr_list);
}
  }
return attr_args;
4633}

4635/* Parse (possibly empty) gnu-attributes.  This is a GNU extension.

 gnu-attributes:
   empty
   gnu-attributes gnu-attribute

 gnu-attribute:
   __attribute__ ( ( gnu-attribute-list ) )

 gnu-attribute-list:
   gnu-attrib
   gnu-attribute_list , gnu-attrib

 gnu-attrib:
   empty
   any-word
   any-word ( gnu-attribute-arguments )

 where "any-word" may be any identifier (including one declared as a
 type), a reserved word storage class specifier, type specifier or
 type qualifier.  ??? This still leaves out most reserved keywords
 (following the old parser), shouldn't we include them?
 When EXPECT_COMMA is true, expect the attribute to be preceded
 by a comma and fail if it isn't.
 When EMPTY_OK is true, allow and consume any number of consecutive
 commas with no attributes in between.  */

4662static tree
4663c_parser_gnu_attribute (c_parser *parser, tree attrs,
	bool expect_comma = false, bool empty_ok = true)
4665{
bool comma_first = c_parser_next_token_is (parser, CPP_COMMA);
if (!comma_first
    && !c_parser_next_token_is (parser, CPP_NAME)
    && !c_parser_next_token_is (parser, CPP_KEYWORD))
  return NULL_TREE(tree) __null;

while (c_parser_next_token_is (parser, CPP_COMMA))
  {
    c_parser_consume_token (parser);
    if (!empty_ok)
return attrs;
  }

tree attr_name = c_parser_gnu_attribute_any_word (parser);
if (attr_name == NULL_TREE(tree) __null)
  return NULL_TREE(tree) __null;

attr_name = canonicalize_attr_name (attr_name);
c_parser_consume_token (parser);

tree attr;
if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
  {
    if (expect_comma && !comma_first)
{
 /* A comma is missing between the last attribute on the chain
    and this one.  */
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
		     "expected %<)%>");
 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
}
    attr = build_tree_list (attr_name, NULL_TREE(tree) __null);
    /* Add this attribute to the list.  */
    attrs = chainon (attrs, attr);
    return attrs;
  }
c_parser_consume_token (parser);

tree attr_args
  = c_parser_attribute_arguments (parser,
		    attribute_takes_identifier_p (attr_name),
		    false, true);

attr = build_tree_list (attr_name, attr_args);
if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
  c_parser_consume_token (parser);
else
  {
    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
		 "expected %<)%>");
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }

if (expect_comma && !comma_first)
  {
    /* A comma is missing between the last attribute on the chain
and this one.  */
    c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
		 "expected %<)%>");
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }

/* Add this attribute to the list.  */
attrs = chainon (attrs, attr);
return attrs;
4731}

4733static tree
4734c_parser_gnu_attributes (c_parser *parser)
4735{
tree attrs = NULL_TREE(tree) __null;
while (c_parser_next_token_is_keyword (parser, RID_ATTRIBUTE))
  {
    bool save_translate_strings_p = parser->translate_strings_p;
    parser->translate_strings_p = false;
    /* Consume the `__attribute__' keyword.  */
    c_parser_consume_token (parser);
    /* Look for the two `(' tokens.  */
    if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
{
 parser->translate_strings_p = save_translate_strings_p;
 return attrs;
}
    if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
{
 parser->translate_strings_p = save_translate_strings_p;
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL__null);
 return attrs;
}
    /* Parse the attribute list.  Require a comma between successive
(possibly empty) attributes.  */
    for (bool expect_comma = false; ; expect_comma = true)
{
 /* Parse a single attribute.  */
 tree attr = c_parser_gnu_attribute (parser, attrs, expect_comma);
 if (attr == error_mark_nodeglobal_trees[TI_ERROR_MARK])
   return attrs;
 if (!attr)
   break;
 attrs = attr;
    }

    /* Look for the two `)' tokens.  */
    if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
c_parser_consume_token (parser);
    else
{
 parser->translate_strings_p = save_translate_strings_p;
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
		     "expected %<)%>");
 return attrs;
}
    if (c_parser_next_token_is (parser, CPP_CLOSE_PAREN))
c_parser_consume_token (parser);
    else
{
 parser->translate_strings_p = save_translate_strings_p;
 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN,
		     "expected %<)%>");
 return attrs;
}
    parser->translate_strings_p = save_translate_strings_p;
  }

return attrs;
4791}

4793/* Parse an optional balanced token sequence.

 balanced-token-sequence:
   balanced-token
   balanced-token-sequence balanced-token

 balanced-token:
   ( balanced-token-sequence[opt] )
   [ balanced-token-sequence[opt] ]
   { balanced-token-sequence[opt] }
   any token other than ()[]{}
4804*/

4806static void
4807c_parser_balanced_token_sequence (c_parser *parser)
4808{
while (true)
  {
    c_token *token = c_parser_peek_token (parser);
    switch (token->type)
{
case CPP_OPEN_BRACE:
 {
   matching_braces braces;
   braces.consume_open (parser);
   c_parser_balanced_token_sequence (parser);
   braces.require_close (parser);
   break;
 }

case CPP_OPEN_PAREN:
 {
   matching_parens parens;
   parens.consume_open (parser);
   c_parser_balanced_token_sequence (parser);
   parens.require_close (parser);
   break;
 }

case CPP_OPEN_SQUARE:
 c_parser_consume_token (parser);
 c_parser_balanced_token_sequence (parser);
 c_parser_require (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
 break;

case CPP_CLOSE_BRACE:
case CPP_CLOSE_PAREN:
case CPP_CLOSE_SQUARE:
case CPP_EOF:
 return;

default:
 c_parser_consume_token (parser);
 break;
}
  }
4849}

4851/* Parse standard (C2X) attributes (including GNU attributes in the
 gnu:: namespace).

 attribute-specifier-sequence:
   attribute-specifier-sequence[opt] attribute-specifier

 attribute-specifier:
   [ [ attribute-list ] ]

 attribute-list:
   attribute[opt]
   attribute-list, attribute[opt]

 attribute:
   attribute-token attribute-argument-clause[opt]

 attribute-token:
   standard-attribute
   attribute-prefixed-token

 standard-attribute:
   identifier

 attribute-prefixed-token:
   attribute-prefix :: identifier

 attribute-prefix:
   identifier

 attribute-argument-clause:
   ( balanced-token-sequence[opt] )

 Keywords are accepted as identifiers for this purpose.
4884*/

4886static tree
4887c_parser_std_attribute (c_parser *parser, bool for_tm)
4888{
c_token *token = c_parser_peek_token (parser);
tree ns, name, attribute;

/* Parse the attribute-token.  */
if (token->type != CPP_NAME && token->type != CPP_KEYWORD)
  {
    c_parser_error (parser, "expected identifier");
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }
name = canonicalize_attr_name (token->value);
c_parser_consume_token (parser);
if (c_parser_next_token_is (parser, CPP_SCOPE))
  {
    ns = name;
    c_parser_consume_token (parser);
    token = c_parser_peek_token (parser);
    if (token->type != CPP_NAME && token->type != CPP_KEYWORD)
{
 c_parser_error (parser, "expected identifier");
 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
}
    name = canonicalize_attr_name (token->value);
    c_parser_consume_token (parser);
  }
else
  ns = NULL_TREE(tree) __null;
attribute = build_tree_list (build_tree_list (ns, name), NULL_TREE(tree) __null);

/* Parse the arguments, if any.  */
const attribute_spec *as = lookup_attribute_spec (TREE_PURPOSE (attribute)((tree_check ((attribute), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 4918, __FUNCTION__, (TREE_LIST)))->list.purpose));
if (c_parser_next_token_is_not (parser, CPP_OPEN_PAREN))
  goto out;
{
  location_t open_loc = c_parser_peek_token (parser)->location;
  matching_parens parens;
  parens.consume_open (parser);
  if ((as && as->max_length == 0)
/* Special-case the transactional-memory attribute "outer",
  which is specially handled but not registered as an
  attribute, to avoid allowing arbitrary balanced token
  sequences as arguments.  */
|| is_attribute_p ("outer", name))
    {
error_at (open_loc, "%qE attribute does not take any arguments", name);
parens.skip_until_found_close (parser);
return error_mark_nodeglobal_trees[TI_ERROR_MARK];
    }
  if (as)
    {
bool takes_identifier
 = (ns != NULL_TREE(tree) __null
    && strcmp (IDENTIFIER_POINTER (ns)((const char *) (tree_check ((ns), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 4940, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), "gnu") == 0
    && attribute_takes_identifier_p (name));
bool require_string
 = (ns == NULL_TREE(tree) __null
    && (strcmp (IDENTIFIER_POINTER (name)((const char *) (tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 4944, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), "deprecated") == 0
 || strcmp (IDENTIFIER_POINTER (name)((const char *) (tree_check ((name), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 4945, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), "nodiscard") == 0));
TREE_VALUE (attribute)((tree_check ((attribute), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 4946, __FUNCTION__, (TREE_LIST)))->list.value)
 = c_parser_attribute_arguments (parser, takes_identifier,
			  require_string, false);
    }
  else
    c_parser_balanced_token_sequence (parser);
  parens.require_close (parser);
}
out:
if (ns == NULL_TREE(tree) __null && !for_tm && !as)
  {
    /* An attribute with standard syntax and no namespace specified
is a constraint violation if it is not one of the known
standard attributes.  Diagnose it here with a pedwarn and
then discard it to prevent a duplicate warning later.  */
    pedwarn (input_location, OPT_Wattributes, "%qE attribute ignored",
      name);
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }
return attribute;
4966}

4968static tree
4969c_parser_std_attribute_specifier (c_parser *parser, bool for_tm)
4970{
location_t loc = c_parser_peek_token (parser)->location;
if (!c_parser_require (parser, CPP_OPEN_SQUARE, "expected %<[%>"))
  return NULL_TREE(tree) __null;
if (!c_parser_require (parser, CPP_OPEN_SQUARE, "expected %<[%>"))
  {
    c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
    return NULL_TREE(tree) __null;
  }
if (!for_tm)
  pedwarn_c11 (loc, OPT_Wpedantic,
 "ISO C does not support %<[[]]%> attributes before C2X");
tree attributes = NULL_TREE(tree) __null;
while (true)
  {
    c_token *token = c_parser_peek_token (parser);
    if (token->type == CPP_CLOSE_SQUARE)
break;
    if (token->type == CPP_COMMA)
{
 c_parser_consume_token (parser);
 continue;
}
    tree attribute = c_parser_std_attribute (parser, for_tm);
    if (attribute != error_mark_nodeglobal_trees[TI_ERROR_MARK])
{
 TREE_CHAIN (attribute)((contains_struct_check ((attribute), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 4996, __FUNCTION__))->common.chain) = attributes;
 attributes = attribute;
}
    if (c_parser_next_token_is_not (parser, CPP_COMMA))
break;
  }
c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE, "expected %<]%>");
return nreverse (attributes);
5005}

5007/* Look past an optional balanced token sequence of raw look-ahead
 tokens starting with the *Nth token.  *N is updated to point to the
 following token.  Return true if such a sequence was found, false
 if the tokens parsed were not balanced.  */

5012static bool
5013c_parser_check_balanced_raw_token_sequence (c_parser *parser, unsigned int *n)
5014{
while (true)
  {
    c_token *token = c_parser_peek_nth_token_raw (parser, *n);
    switch (token->type)
{
case CPP_OPEN_BRACE:
 {
   ++*n;
   if (c_parser_check_balanced_raw_token_sequence (parser, n))
     {
token = c_parser_peek_nth_token_raw (parser, *n);
if (token->type == CPP_CLOSE_BRACE)
  ++*n;
else
  return false;
     }
   else
     return false;
   break;
 }

case CPP_OPEN_PAREN:
 {
   ++*n;
   if (c_parser_check_balanced_raw_token_sequence (parser, n))
     {
token = c_parser_peek_nth_token_raw (parser, *n);
if (token->type == CPP_CLOSE_PAREN)
  ++*n;
else
  return false;
     }
   else
     return false;
   break;
 }

case CPP_OPEN_SQUARE:
 {
   ++*n;
   if (c_parser_check_balanced_raw_token_sequence (parser, n))
     {
token = c_parser_peek_nth_token_raw (parser, *n);
if (token->type == CPP_CLOSE_SQUARE)
  ++*n;
else
  return false;
     }
   else
     return false;
   break;
 }

case CPP_CLOSE_BRACE:
case CPP_CLOSE_PAREN:
case CPP_CLOSE_SQUARE:
case CPP_EOF:
 return true;

default:
 ++*n;
 break;
}
  }
5079}

5081/* Return whether standard attributes start with the Nth token.  */

5083static bool
5084c_parser_nth_token_starts_std_attributes (c_parser *parser, unsigned int n)
5085{
if (!(c_parser_peek_nth_token (parser, n)->type == CPP_OPEN_SQUARE
&& c_parser_peek_nth_token (parser, n + 1)->type == CPP_OPEN_SQUARE))
  return false;
/* In C, '[[' must start attributes.  In Objective-C, we need to
   check whether '[[' is matched by ']]'.  */
if (!c_dialect_objc ()((c_language & clk_objc) != 0))
  return true;
n += 2;
if (!c_parser_check_balanced_raw_token_sequence (parser, &n))
  return false;
c_token *token = c_parser_peek_nth_token_raw (parser, n);
if (token->type != CPP_CLOSE_SQUARE)
  return false;
token = c_parser_peek_nth_token_raw (parser, n + 1);
return token->type == CPP_CLOSE_SQUARE;
5101}

5103static tree
5104c_parser_std_attribute_specifier_sequence (c_parser *parser)
5105{
tree attributes = NULL_TREE(tree) __null;
do
  {
    tree attrs = c_parser_std_attribute_specifier (parser, false);
    attributes = chainon (attributes, attrs);
  }
while (c_parser_nth_token_starts_std_attributes (parser, 1));
return attributes;
5114}

5116/* Parse a type name (C90 6.5.5, C99 6.7.6, C11 6.7.7).  ALIGNAS_OK
 says whether alignment specifiers are OK (only in cases that might
 be the type name of a compound literal).

 type-name:
   specifier-qualifier-list abstract-declarator[opt]
5122*/

5124struct c_type_name *
5125c_parser_type_name (c_parser *parser, bool alignas_ok)
5126{
struct c_declspecs *specs = build_null_declspecs ();
struct c_declarator *declarator;
struct c_type_name *ret;
bool dummy = false;
c_parser_declspecs (parser, specs, false, true, true, alignas_ok, false,
      false, true, cla_prefer_type);
if (!specs->declspecs_seen_p)
  {
    c_parser_error (parser, "expected specifier-qualifier-list");
    return NULL__null;
  }
if (specs->type != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  {
    pending_xref_error ();
    finish_declspecs (specs);
  }
declarator = c_parser_declarator (parser,
		    specs->typespec_kind != ctsk_none,
		    C_DTR_ABSTRACT, &dummy);
if (declarator == NULL__null)
  return NULL__null;
ret = XOBNEW (&parser_obstack, struct c_type_name)((struct c_type_name *) __extension__ ({ struct obstack *__h =
 ((&parser_obstack)); __extension__ ({ struct obstack *__o
 = (__h); size_t __len = ((sizeof (struct c_type_name))); if (
__extension__ ({ struct obstack const *__o1 = (__o); (size_t)
 (__o1->chunk_limit - __o1->next_free); }) < __len) _obstack_newchunk
 (__o, __len); ((void) ((__o)->next_free += (__len))); });
 __extension__ ({ struct obstack *__o1 = (__h); void *__value
 = (void *) __o1->object_base; if (__o1->next_free == __value
) __o1->maybe_empty_object = 1; __o1->next_free = ((sizeof
 (ptrdiff_t) < sizeof (void *) ? (__o1->object_base) : (
char *) 0) + (((__o1->next_free) - (sizeof (ptrdiff_t) <
 sizeof (void *) ? (__o1->object_base) : (char *) 0) + (__o1
->alignment_mask)) & ~(__o1->alignment_mask))); if (
(size_t) (__o1->next_free - (char *) __o1->chunk) > (
size_t) (__o1->chunk_limit - (char *) __o1->chunk)) __o1
->next_free = __o1->chunk_limit; __o1->object_base =
 __o1->next_free; __value; }); }));
ret->specs = specs;
ret->declarator = declarator;
return ret;
5152}

5154/* Parse an initializer (C90 6.5.7, C99 6.7.8, C11 6.7.9).

 initializer:
   assignment-expression
   { initializer-list }
   { initializer-list , }

 initializer-list:
   designation[opt] initializer
   initializer-list , designation[opt] initializer

 designation:
   designator-list =

 designator-list:
   designator
   designator-list designator

 designator:
   array-designator
   . identifier

 array-designator:
   [ constant-expression ]

 GNU extensions:

 initializer:
   { }

 designation:
   array-designator
   identifier :

 array-designator:
   [ constant-expression ... constant-expression ]

 Any expression without commas is accepted in the syntax for the
 constant-expressions, with non-constant expressions rejected later.

 This function is only used for top-level initializers; for nested
 ones, see c_parser_initval.  */

5197static struct c_expr
5198c_parser_initializer (c_parser *parser)
5199{
if (c_parser_next_token_is (parser, CPP_OPEN_BRACE))
  return c_parser_braced_init (parser, NULL_TREE(tree) __null, false, NULL__null);
else
  {
    struct c_expr ret;
    location_t loc = c_parser_peek_token (parser)->location;
    ret = c_parser_expr_no_commas (parser, NULL__null);
    if (TREE_CODE (ret.value)((enum tree_code) (ret.value)->base.code) != STRING_CST
 && TREE_CODE (ret.value)((enum tree_code) (ret.value)->base.code) != COMPOUND_LITERAL_EXPR)
ret = convert_lvalue_to_rvalue (loc, ret, true, true);
    return ret;
  }
5212}

5214/* The location of the last comma within the current initializer list,
 or UNKNOWN_LOCATION if not within one.  */

5217location_t last_init_list_comma;

5219/* Parse a braced initializer list.  TYPE is the type specified for a
 compound literal, and NULL_TREE for other initializers and for
 nested braced lists.  NESTED_P is true for nested braced lists,
 false for the list of a compound literal or the list that is the
 top-level initializer in a declaration.  */

5225static struct c_expr
5226c_parser_braced_init (c_parser *parser, tree type, bool nested_p,
      struct obstack *outer_obstack)
5228{
struct c_expr ret;
struct obstack braced_init_obstack;
location_t brace_loc = c_parser_peek_token (parser)->location;
gcc_obstack_init (&braced_init_obstack)_obstack_begin (((&braced_init_obstack)), (memory_block_pool
::block_size), (0), (mempool_obstack_chunk_alloc), (mempool_obstack_chunk_free
));
gcc_assert (c_parser_next_token_is (parser, CPP_OPEN_BRACE))((void)(!(c_parser_next_token_is (parser, CPP_OPEN_BRACE)) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5233, __FUNCTION__), 0 : 0));
matching_braces braces;
braces.consume_open (parser);
if (nested_p)
  {
    finish_implicit_inits (brace_loc, outer_obstack);
    push_init_level (brace_loc, 0, &braced_init_obstack);
  }
else
  really_start_incremental_init (type);
if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
  {
    pedwarn (brace_loc, OPT_Wpedantic, "ISO C forbids empty initializer braces");
  }
else
  {
    /* Parse a non-empty initializer list, possibly with a trailing
comma.  */
    while (true)
{
 c_parser_initelt (parser, &braced_init_obstack);
 if (parser->error)
   break;
 if (c_parser_next_token_is (parser, CPP_COMMA))
   {
     last_init_list_comma = c_parser_peek_token (parser)->location;
     c_parser_consume_token (parser);
   }
 else
   break;
 if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
   break;
}
  }
c_token *next_tok = c_parser_peek_token (parser);
if (next_tok->type != CPP_CLOSE_BRACE)
  {
    ret.set_error ();
    ret.original_code = ERROR_MARK;
    ret.original_type = NULL__null;
    braces.skip_until_found_close (parser);
    pop_init_level (brace_loc, 0, &braced_init_obstack, last_init_list_comma);
    obstack_free (&braced_init_obstack, NULL)__extension__ ({ struct obstack *__o = (&braced_init_obstack
); void *__obj = (void *) (__null); if (__obj > (void *) __o
->chunk && __obj < (void *) __o->chunk_limit
) __o->next_free = __o->object_base = (char *) __obj; else
 _obstack_free (__o, __obj); });
    return ret;
  }
location_t close_loc = next_tok->location;
c_parser_consume_token (parser);
ret = pop_init_level (brace_loc, 0, &braced_init_obstack, close_loc);
obstack_free (&braced_init_obstack, NULL)__extension__ ({ struct obstack *__o = (&braced_init_obstack
); void *__obj = (void *) (__null); if (__obj > (void *) __o
->chunk && __obj < (void *) __o->chunk_limit
) __o->next_free = __o->object_base = (char *) __obj; else
 _obstack_free (__o, __obj); });
set_c_expr_source_range (&ret, brace_loc, close_loc);
return ret;
5284}

5286/* Parse a nested initializer, including designators.  */

5288static void
5289c_parser_initelt (c_parser *parser, struct obstack * braced_init_obstack)
5290{
/* Parse any designator or designator list.  A single array
   designator may have the subsequent "=" omitted in GNU C, but a
   longer list or a structure member designator may not.  */
if (c_parser_next_token_is (parser, CPP_NAME)
    && c_parser_peek_2nd_token (parser)->type == CPP_COLON)
  {
    /* Old-style structure member designator.  */
    set_init_label (c_parser_peek_token (parser)->location,
      c_parser_peek_token (parser)->value,
      c_parser_peek_token (parser)->location,
      braced_init_obstack);
    /* Use the colon as the error location.  */
    pedwarn (c_parser_peek_2nd_token (parser)->location, OPT_Wpedantic,
      "obsolete use of designated initializer with %<:%>");
    c_parser_consume_token (parser);
    c_parser_consume_token (parser);
  }
else
  {
    /* des_seen is 0 if there have been no designators, 1 if there
has been a single array designator and 2 otherwise.  */
    int des_seen = 0;
    /* Location of a designator.  */
    location_t des_loc = UNKNOWN_LOCATION((location_t) 0);  /* Quiet warning.  */
    while (c_parser_next_token_is (parser, CPP_OPEN_SQUARE)
    || c_parser_next_token_is (parser, CPP_DOT))
{
 int des_prev = des_seen;
 if (!des_seen)
   des_loc = c_parser_peek_token (parser)->location;
 if (des_seen < 2)
   des_seen++;
 if (c_parser_next_token_is (parser, CPP_DOT))
   {
     des_seen = 2;
     c_parser_consume_token (parser);
     if (c_parser_next_token_is (parser, CPP_NAME))
{
  set_init_label (des_loc, c_parser_peek_token (parser)->value,
		  c_parser_peek_token (parser)->location,
		  braced_init_obstack);
  c_parser_consume_token (parser);
}
     else
{
  struct c_expr init;
  init.set_error ();
  init.original_code = ERROR_MARK;
  init.original_type = NULL__null;
  c_parser_error (parser, "expected identifier");
  c_parser_skip_until_found (parser, CPP_COMMA, NULL__null);
  process_init_element (input_location, init, false,
			braced_init_obstack);
  return;
}
   }
 else
   {
     tree first, second;
     location_t ellipsis_loc = UNKNOWN_LOCATION((location_t) 0);  /* Quiet warning.  */
     location_t array_index_loc = UNKNOWN_LOCATION((location_t) 0);
     /* ??? Following the old parser, [ objc-receiver
 objc-message-args ] is accepted as an initializer,
 being distinguished from a designator by what follows
 the first assignment expression inside the square
 brackets, but after a first array designator a
 subsequent square bracket is for Objective-C taken to
 start an expression, using the obsolete form of
 designated initializer without '=', rather than
 possibly being a second level of designation: in LALR
 terms, the '[' is shifted rather than reducing
 designator to designator-list.  */
     if (des_prev == 1 && c_dialect_objc ()((c_language & clk_objc) != 0))
{
  des_seen = des_prev;
  break;
}
     if (des_prev == 0 && c_dialect_objc ()((c_language & clk_objc) != 0))
{
  /* This might be an array designator or an
     Objective-C message expression.  If the former,
     continue parsing here; if the latter, parse the
     remainder of the initializer given the starting
     primary-expression.  ??? It might make sense to
     distinguish when des_prev == 1 as well; see
     previous comment.  */
  tree rec, args;
  struct c_expr mexpr;
  c_parser_consume_token (parser);
  if (c_parser_peek_token (parser)->type == CPP_NAME
      && ((c_parser_peek_token (parser)->id_kind
	   == C_ID_TYPENAME)
	  || (c_parser_peek_token (parser)->id_kind
	      == C_ID_CLASSNAME)))
    {
      /* Type name receiver.  */
      tree id = c_parser_peek_token (parser)->value;
      c_parser_consume_token (parser);
      rec = objc_get_class_reference (id);
      goto parse_message_args;
    }
  first = c_parser_expr_no_commas (parser, NULL__null).value;
  mark_exp_read (first);
  if (c_parser_next_token_is (parser, CPP_ELLIPSIS)
      || c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
    goto array_desig_after_first;
  /* Expression receiver.  So far only one part
     without commas has been parsed; there might be
     more of the expression.  */
  rec = first;
  while (c_parser_next_token_is (parser, CPP_COMMA))
    {
      struct c_expr next;
      location_t comma_loc, exp_loc;
      comma_loc = c_parser_peek_token (parser)->location;
      c_parser_consume_token (parser);
      exp_loc = c_parser_peek_token (parser)->location;
      next = c_parser_expr_no_commas (parser, NULL__null);
      next = convert_lvalue_to_rvalue (exp_loc, next,
				       true, true);
      rec = build_compound_expr (comma_loc, rec, next.value);
    }
parse_message_args:
  /* Now parse the objc-message-args.  */
  args = c_parser_objc_message_args (parser);
  c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
			     "expected %<]%>");
  mexpr.value
    = objc_build_message_expr (rec, args);
  mexpr.original_code = ERROR_MARK;
  mexpr.original_type = NULL__null;
  /* Now parse and process the remainder of the
     initializer, starting with this message
     expression as a primary-expression.  */
  c_parser_initval (parser, &mexpr, braced_init_obstack);
  return;
}
     c_parser_consume_token (parser);
     array_index_loc = c_parser_peek_token (parser)->location;
     first = c_parser_expr_no_commas (parser, NULL__null).value;
     mark_exp_read (first);
   array_desig_after_first:
     if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
{
  ellipsis_loc = c_parser_peek_token (parser)->location;
  c_parser_consume_token (parser);
  second = c_parser_expr_no_commas (parser, NULL__null).value;
  mark_exp_read (second);
}
     else
second = NULL_TREE(tree) __null;
     if (c_parser_next_token_is (parser, CPP_CLOSE_SQUARE))
{
  c_parser_consume_token (parser);
  set_init_index (array_index_loc, first, second,
		  braced_init_obstack);
  if (second)
    pedwarn (ellipsis_loc, OPT_Wpedantic,
	     "ISO C forbids specifying range of elements to initialize");
}
     else
c_parser_skip_until_found (parser, CPP_CLOSE_SQUARE,
			   "expected %<]%>");
   }
}
    if (des_seen >= 1)
{
 if (c_parser_next_token_is (parser, CPP_EQ))
   {
     pedwarn_c90 (des_loc, OPT_Wpedantic,
	   "ISO C90 forbids specifying subobject "
	   "to initialize");
     c_parser_consume_token (parser);
   }
 else
   {
     if (des_seen == 1)
pedwarn (c_parser_peek_token (parser)->location, OPT_Wpedantic,
	 "obsolete use of designated initializer without %<=%>");
     else
{
  struct c_expr init;
  init.set_error ();
  init.original_code = ERROR_MARK;
  init.original_type = NULL__null;
  c_parser_error (parser, "expected %<=%>");
  c_parser_skip_until_found (parser, CPP_COMMA, NULL__null);
  process_init_element (input_location, init, false,
			braced_init_obstack);
  return;
}
   }
}
  }
c_parser_initval (parser, NULL__null, braced_init_obstack);
5486}

5488/* Parse a nested initializer; as c_parser_initializer but parses
 initializers within braced lists, after any designators have been
 applied.  If AFTER is not NULL then it is an Objective-C message
 expression which is the primary-expression starting the
 initializer.  */

5494static void
5495c_parser_initval (c_parser *parser, struct c_expr *after,
  struct obstack * braced_init_obstack)
5497{
struct c_expr init;
gcc_assert (!after || c_dialect_objc ())((void)(!(!after || ((c_language & clk_objc) != 0)) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5499, __FUNCTION__), 0 : 0));
location_t loc = c_parser_peek_token (parser)->location;

if (c_parser_next_token_is (parser, CPP_OPEN_BRACE) && !after)
  init = c_parser_braced_init (parser, NULL_TREE(tree) __null, true,
		 braced_init_obstack);
else
  {
    init = c_parser_expr_no_commas (parser, after);
    if (init.value != NULL_TREE(tree) __null
 && TREE_CODE (init.value)((enum tree_code) (init.value)->base.code) != STRING_CST
 && TREE_CODE (init.value)((enum tree_code) (init.value)->base.code) != COMPOUND_LITERAL_EXPR)
init = convert_lvalue_to_rvalue (loc, init, true, true);
  }
process_init_element (loc, init, false, braced_init_obstack);
5514}

5516/* Parse a compound statement (possibly a function body) (C90 6.6.2,
 C99 6.8.2, C11 6.8.2, C2X 6.8.2).

 compound-statement:
   { block-item-list[opt] }
   { label-declarations block-item-list }

 block-item-list:
   block-item
   block-item-list block-item

 block-item:
   label
   nested-declaration
   statement

 nested-declaration:
   declaration

 GNU extensions:

 compound-statement:
   { label-declarations block-item-list }

 nested-declaration:
   __extension__ nested-declaration
   nested-function-definition

 label-declarations:
   label-declaration
   label-declarations label-declaration

 label-declaration:
   __label__ identifier-list ;

 Allowing the mixing of declarations and code is new in C99.  The
 GNU syntax also permits (not shown above) labels at the end of
 compound statements, which yield an error.  We don't allow labels
 on declarations; this might seem like a natural extension, but
 there would be a conflict between gnu-attributes on the label and
 prefix gnu-attributes on the declaration.  ??? The syntax follows the
 old parser in requiring something after label declarations.
 Although they are erroneous if the labels declared aren't defined,
 is it useful for the syntax to be this way?

 OpenACC:

 block-item:
   openacc-directive

 openacc-directive:
   update-directive

 OpenMP:

 block-item:
   openmp-directive

 openmp-directive:
   barrier-directive
   flush-directive
   taskwait-directive
   taskyield-directive
   cancel-directive
   cancellation-point-directive  */

5582static tree
5583c_parser_compound_statement (c_parser *parser, location_t *endlocp)
5584{
tree stmt;
location_t brace_loc;
brace_loc = c_parser_peek_token (parser)->location;
if (!c_parser_require (parser, CPP_OPEN_BRACE, "expected %<{%>"))
  {
    /* Ensure a scope is entered and left anyway to avoid confusion
if we have just prepared to enter a function body.  */
    stmt = c_begin_compound_stmt (true);
    c_end_compound_stmt (brace_loc, stmt, true);
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }
stmt = c_begin_compound_stmt (true);
location_t end_loc = c_parser_compound_statement_nostart (parser);
if (endlocp)
  *endlocp = end_loc;

return c_end_compound_stmt (brace_loc, stmt, true);
5602}

5604/* Parse a compound statement except for the opening brace.  This is
 used for parsing both compound statements and statement expressions
 (which follow different paths to handling the opening).  */

5608static location_t
5609c_parser_compound_statement_nostart (c_parser *parser)
5610{
bool last_stmt = false;
bool last_label = false;
bool save_valid_for_pragma = valid_location_for_stdc_pragma_p ();
location_t label_loc = UNKNOWN_LOCATION((location_t) 0);  /* Quiet warning.  */
if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
  {
    location_t endloc = c_parser_peek_token (parser)->location;
    add_debug_begin_stmt (endloc);
    c_parser_consume_token (parser);
    return endloc;
  }
mark_valid_location_for_stdc_pragma (true);
if (c_parser_next_token_is_keyword (parser, RID_LABEL))
  {
    /* Read zero or more forward-declarations for labels that nested
functions can jump to.  */
    mark_valid_location_for_stdc_pragma (false);
    while (c_parser_next_token_is_keyword (parser, RID_LABEL))
{
 label_loc = c_parser_peek_token (parser)->location;
 c_parser_consume_token (parser);
 /* Any identifiers, including those declared as type names,
    are OK here.  */
 while (true)
   {
     tree label;
     if (c_parser_next_token_is_not (parser, CPP_NAME))
{
  c_parser_error (parser, "expected identifier");
  break;
}
     label
= declare_label (c_parser_peek_token (parser)->value);
     C_DECLARED_LABEL_FLAG (label)((tree_not_check2 ((label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5644, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1) = 1;
     add_stmt (build_stmt (label_loc, DECL_EXPR, label));
     c_parser_consume_token (parser);
     if (c_parser_next_token_is (parser, CPP_COMMA))
c_parser_consume_token (parser);
     else
break;
   }
 c_parser_skip_until_found (parser, CPP_SEMICOLON, "expected %<;%>");
}
    pedwarn (label_loc, OPT_Wpedantic, "ISO C forbids label declarations");
  }
/* We must now have at least one statement, label or declaration.  */
if (c_parser_next_token_is (parser, CPP_CLOSE_BRACE))
  {
    mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
    c_parser_error (parser, "expected declaration or statement");
    location_t endloc = c_parser_peek_token (parser)->location;
    c_parser_consume_token (parser);
    return endloc;
  }
while (c_parser_next_token_is_not (parser, CPP_CLOSE_BRACE))
  {
    location_t loc = c_parser_peek_token (parser)->location;
    loc = expansion_point_location_if_in_system_header (loc);
    /* Standard attributes may start a label, statement or declaration.  */
    bool have_std_attrs
= c_parser_nth_token_starts_std_attributes (parser, 1);
    tree std_attrs = NULL_TREE(tree) __null;
    if (have_std_attrs)
std_attrs = c_parser_std_attribute_specifier_sequence (parser);
    if (c_parser_next_token_is_keyword (parser, RID_CASE)
 || c_parser_next_token_is_keyword (parser, RID_DEFAULT)
 || (c_parser_next_token_is (parser, CPP_NAME)
     && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
{
 if (c_parser_next_token_is_keyword (parser, RID_CASE))
   label_loc = c_parser_peek_2nd_token (parser)->location;
 else
   label_loc = c_parser_peek_token (parser)->location;
 last_label = true;
 last_stmt = false;
 mark_valid_location_for_stdc_pragma (false);
 c_parser_label (parser, std_attrs);
}
    else if (c_parser_next_tokens_start_declaration (parser)
      || (have_std_attrs
   && c_parser_next_token_is (parser, CPP_SEMICOLON)))
{
 if (last_label)
   pedwarn_c11 (c_parser_peek_token (parser)->location, OPT_Wpedantic,
	 "a label can only be part of a statement and "
	 "a declaration is not a statement");

 mark_valid_location_for_stdc_pragma (false);
 bool fallthru_attr_p = false;
 c_parser_declaration_or_fndef (parser, true, !have_std_attrs,
			 true, true, true, NULL__null,
			 vNULL, have_std_attrs, std_attrs,
			 NULL__null, &fallthru_attr_p);

 if (last_stmt && !fallthru_attr_p)
   pedwarn_c90 (loc, OPT_Wdeclaration_after_statement,
	 "ISO C90 forbids mixed declarations and code");
 last_stmt = fallthru_attr_p;
 last_label = false;
}
    else if (c_parser_next_token_is_keyword (parser, RID_EXTENSION))
{
 /* __extension__ can start a declaration, but is also an
    unary operator that can start an expression.  Consume all
    but the last of a possible series of __extension__ to
    determine which.  If standard attributes have already
    been seen, it must start a statement, not a declaration,
    but standard attributes starting a declaration may appear
    after __extension__.  */
 while (c_parser_peek_2nd_token (parser)->type == CPP_KEYWORD
 && (c_parser_peek_2nd_token (parser)->keyword
     == RID_EXTENSION))
   c_parser_consume_token (parser);
 if (!have_std_attrs
     && (c_token_starts_declaration (c_parser_peek_2nd_token (parser))
  || c_parser_nth_token_starts_std_attributes (parser, 2)))
   {
     int ext;
     ext = disable_extension_diagnostics ();
     c_parser_consume_token (parser);
     last_label = false;
     mark_valid_location_for_stdc_pragma (false);
     c_parser_declaration_or_fndef (parser, true, true, true, true,
			     true, NULL__null, vNULL);
     /* Following the old parser, __extension__ does not
 disable this diagnostic.  */
     restore_extension_diagnostics (ext);
     if (last_stmt)
pedwarn_c90 (loc, OPT_Wdeclaration_after_statement,
	     "ISO C90 forbids mixed declarations and code");
     last_stmt = false;
   }
 else
   goto statement;
}
    else if (c_parser_next_token_is (parser, CPP_PRAGMA))
{
 if (have_std_attrs)
   c_parser_error (parser, "expected declaration or statement");
 /* External pragmas, and some omp pragmas, are not associated
    with regular c code, and so are not to be considered statements
    syntactically.  This ensures that the user doesn't put them
    places that would turn into syntax errors if the directive
    were ignored.  */
 if (c_parser_pragma (parser,
	       last_label ? pragma_stmt : pragma_compound,
	       NULL__null))
   last_label = false, last_stmt = true;
}
    else if (c_parser_next_token_is (parser, CPP_EOF))
{
 mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
 c_parser_error (parser, "expected declaration or statement");
 return c_parser_peek_token (parser)->location;
}
    else if (c_parser_next_token_is_keyword (parser, RID_ELSE))
      {
        if (parser->in_if_block)
          {
     mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
     error_at (loc, "expected %<}%> before %<else%>");
     return c_parser_peek_token (parser)->location;
          }
        else
          {
            error_at (loc, "%<else%> without a previous %<if%>");
            c_parser_consume_token (parser);
            continue;
          }
      }
    else
{
statement:
 c_warn_unused_attributes (std_attrs);
 last_label = false;
 last_stmt = true;
 mark_valid_location_for_stdc_pragma (false);
 c_parser_statement_after_labels (parser, NULL__null);
}

    parser->error = false;
  }
if (last_label)
  pedwarn_c11 (label_loc, OPT_Wpedantic, "label at end of compound statement");
location_t endloc = c_parser_peek_token (parser)->location;
c_parser_consume_token (parser);
/* Restore the value we started with.  */
mark_valid_location_for_stdc_pragma (save_valid_for_pragma);
return endloc;
5800}

5802/* Parse all consecutive labels, possibly preceded by standard
 attributes.  In this context, a statement is required, not a
 declaration, so attributes must be followed by a statement that is
 not just a semicolon.  */

5807static void
5808c_parser_all_labels (c_parser *parser)
5809{
tree std_attrs = NULL__null;
if (c_parser_nth_token_starts_std_attributes (parser, 1))
  {
    std_attrs = c_parser_std_attribute_specifier_sequence (parser);
    if (c_parser_next_token_is (parser, CPP_SEMICOLON))
c_parser_error (parser, "expected statement");
  }
while (c_parser_next_token_is_keyword (parser, RID_CASE)
|| c_parser_next_token_is_keyword (parser, RID_DEFAULT)
|| (c_parser_next_token_is (parser, CPP_NAME)
    && c_parser_peek_2nd_token (parser)->type == CPP_COLON))
  {
    c_parser_label (parser, std_attrs);
    std_attrs = NULL__null;
    if (c_parser_nth_token_starts_std_attributes (parser, 1))
{
 std_attrs = c_parser_std_attribute_specifier_sequence (parser);
 if (c_parser_next_token_is (parser, CPP_SEMICOLON))
   c_parser_error (parser, "expected statement");
}
  }
 if (std_attrs)
   c_warn_unused_attributes (std_attrs);
5833}

5835/* Parse a label (C90 6.6.1, C99 6.8.1, C11 6.8.1).

 label:
   identifier : gnu-attributes[opt]
   case constant-expression :
   default :

 GNU extensions:

 label:
   case constant-expression ... constant-expression :

 The use of gnu-attributes on labels is a GNU extension.  The syntax in
 GNU C accepts any expressions without commas, non-constant
 expressions being rejected later.  Any standard
 attribute-specifier-sequence before the first label has been parsed
 in the caller, to distinguish statements from declarations.  Any
 attribute-specifier-sequence after the label is parsed in this
 function.  */
5854static void
5855c_parser_label (c_parser *parser, tree std_attrs)
5856{
location_t loc1 = c_parser_peek_token (parser)->location;
tree label = NULL_TREE(tree) __null;

/* Remember whether this case or a user-defined label is allowed to fall
   through to.  */
bool fallthrough_p = c_parser_peek_token (parser)->flags & PREV_FALLTHROUGH(1 << 5);

if (c_parser_next_token_is_keyword (parser, RID_CASE))
  {
    tree exp1, exp2;
    c_parser_consume_token (parser);
    exp1 = c_parser_expr_no_commas (parser, NULL__null).value;
    if (c_parser_next_token_is (parser, CPP_COLON))
{
 c_parser_consume_token (parser);
 label = do_case (loc1, exp1, NULL_TREE(tree) __null);
}
    else if (c_parser_next_token_is (parser, CPP_ELLIPSIS))
{
 c_parser_consume_token (parser);
 exp2 = c_parser_expr_no_commas (parser, NULL__null).value;
 if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
   label = do_case (loc1, exp1, exp2);
}
    else
c_parser_error (parser, "expected %<:%> or %<...%>");
  }
else if (c_parser_next_token_is_keyword (parser, RID_DEFAULT))
  {
    c_parser_consume_token (parser);
    if (c_parser_require (parser, CPP_COLON, "expected %<:%>"))
label = do_case (loc1, NULL_TREE(tree) __null, NULL_TREE(tree) __null);
  }
else
  {
    tree name = c_parser_peek_token (parser)->value;
    tree tlab;
    tree attrs;
    location_t loc2 = c_parser_peek_token (parser)->location;
    gcc_assert (c_parser_next_token_is (parser, CPP_NAME))((void)(!(c_parser_next_token_is (parser, CPP_NAME)) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5896, __FUNCTION__), 0 : 0));
    c_parser_consume_token (parser);
    gcc_assert (c_parser_next_token_is (parser, CPP_COLON))((void)(!(c_parser_next_token_is (parser, CPP_COLON)) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5898, __FUNCTION__), 0 : 0));
    c_parser_consume_token (parser);
    attrs = c_parser_gnu_attributes (parser);
    tlab = define_label (loc2, name);
    if (tlab)
{
 decl_attributes (&tlab, attrs, 0);
 decl_attributes (&tlab, std_attrs, 0);
 label = add_stmt (build_stmt (loc1, LABEL_EXPR, tlab));
}
    if (attrs
 && c_parser_next_tokens_start_declaration (parser))
 warning_at (loc2, OPT_Wattributes, "GNU-style attribute between"
      " label and declaration appertains to the label");
  }
if (label)
  {
    if (TREE_CODE (label)((enum tree_code) (label)->base.code) == LABEL_EXPR)
FALLTHROUGH_LABEL_P (LABEL_EXPR_LABEL (label))((tree_check (((*((const_cast<tree*> (tree_operand_check
 (((tree_check ((label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5916, __FUNCTION__, (LABEL_EXPR)))), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5916, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5916, __FUNCTION__, (LABEL_DECL)))->base.private_flag) = fallthrough_p;
    else
FALLTHROUGH_LABEL_P (CASE_LABEL (label))((tree_check (((*((const_cast<tree*> (tree_operand_check
 (((tree_check ((label), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5918, __FUNCTION__, (CASE_LABEL_EXPR)))), (2), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5918, __FUNCTION__)))))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/c/c-parser.c"
, 5918, __FUNCTION__, (LABEL_DECL)))->base.private_flag) = fallthrough_p;
  }
5920}

5922/* Parse a statement (C90 6.6, C99 6.8, C11 6.8).

 statement:
   labeled-statement
   attribute-specifier-sequence[opt] compound-statement
   expression-statement
   attribute-specifier-sequence[opt] selection-statement
   attribute-specifier-sequence[opt] iteration-statement
   attribute-specifier-sequence[opt] jump-statement

 labeled-statement:
   attribute-specifier-sequence[opt] label statement

 expression-statement:
   expression[opt] ;
   attribute-specifier-sequence expression ;

 selection-statement:
   if-statement
   switch-statement

 iteration-statement:
   while-statement
   do-statement
   for-statement

 jump-statement:
   goto identifier ;
   continue ;
   break ;
   return expression[opt] ;

 GNU extensions:

 statement:
   attribute-specifier-sequence[opt] asm-statement

 jump-statement:
   goto * expression ;

 expression-statement:
   gnu-attributes ;

 Objective-C:

 statement:
   attribute-specifier-sequence[opt] objc-throw-statement
   attribute-specifier-sequence[opt] objc-try-catch-statement
   attribute-specifier-sequence[opt] objc-synchronized-statement

 objc-throw-statement:
   @throw expression ;
   @throw ;

 OpenACC:

 statement:
   attribute-specifier-sequence[opt] openacc-construct

 openacc-construct:
   parallel-construct
   kernels-construct
   data-construct
   loop-construct

 parallel-construct:
   parallel-directive structured-block

 kernels-construct:
   kernels-directive structured-block

 data-construct:
   data-directive structured-block

 loop-construct:
   loop-directive structured-block

 OpenMP:

 statement:
   attribute-specifier-sequence[opt] openmp-construct

 openmp-construct:
   parallel-construct
   for-construct
   simd-construct
   for-simd-construct
   sections-construct
   single-construct
   parallel-for-construct
   parallel-for-simd-construct
   parallel-sections-construct
   master-construct
   critical-construct
   atomic-construct
   ordered-construct

 parallel-construct:
   parallel-directive structured-block

 for-construct:
   for-directive iteration-statement

 simd-construct:
   simd-directive iteration-statements

 for-simd-construct:
   for-simd-directive iteration-statements

 sections-construct:
   sections-directive section-scope

 single-construct:
   single-directive structured-block

 parallel-for-construct:
   parallel-for-directive iteration-statement

 parallel-for-simd-construct:
   parallel-for-simd-directive iteration-statement

 parallel-sections-construct:
   parallel-sections-directive section-scope

 master-construct:
   master-directive structured-block

 critical-construct:
   critical-directive structured-block

 atomic-construct:
   atomic-directive expression-statement

 ordered-construct:
   ordered-directive structured-block

 Transactional Memory:

 statement:
   attribute-specifier-sequence[opt] transaction-statement
   attribute-specifier-sequence[opt] transaction-cancel-statement

 IF_P is used to track whether there's a (possibly labeled) if statement
 which is not enclosed in braces and has an else clause.  This is used to
 implement -Wparentheses.  */

6068static void
6069c_parser_statement (c_parser *parser, bool *if_p, location_t *loc_after_labels)
6070{
c_parser_all_labels (parser);
if (loc_after_labels)
  *loc_after_labels = c_parser_peek_token (parser)->location;
c_parser_statement_after_labels (parser, if_p, NULL__null);
6075}

6077/* Parse a statement, other than a labeled statement.  CHAIN is a vector
 of if-else-if conditions.  All labels and standard attributes have
 been parsed in the caller.

 IF_P is used to track whether there's a (possibly labeled) if statement
 which is not enclosed in braces and has an else clause.  This is used to
 implement -Wparentheses.  */

6085static void
6086c_parser_statement_after_labels (c_parser *parser, bool *if_p,
		 vec<tree> *chain)
6088{
location_t loc = c_parser_peek_token (parser)->location;
tree stmt = NULL_TREE(tree) __null;
bool in_if_block = parser->in_if_block;
parser->in_if_block = false;
if (if_p != NULL__null)
  *if_p = false;

if (c_parser_peek_token (parser)->type != CPP_OPEN_BRACE)
  add_debug_begin_stmt (loc);

switch (c_parser_peek_token (parser)->type)
  {
  case CPP_OPEN_BRACE:
    add_stmt (c_parser_compound_statement (parser));
    break;
  case CPP_KEYWORD:
    switch (c_parser_peek_token (parser)->keyword)
{
case RID_IF:
 c_parser_if_statement (parser, if_p, chain);
 break;
case RID_SWITCH:
 c_parser_switch_statement (parser, if_p);
 break;
case RID_WHILE:
 c_parser_while_statement (parser, false, 0, if_p);
 break;
case RID_DO:
 c_parser_do_statement (parser, false, 0);
 break;
case RID_FOR:
 c_parser_for_statement (parser, false, 0, if_p);
 break;
case RID_GOTO:
 c_parser_consume_token (parser);
 if (c_parser_next_token_is (parser, CPP_NAME))
   {
     stmt = c_finish_goto_label (loc,
			  c_parser_peek_token (parser)->value);
     c_parser_consume_token (parser);
   }
 else if (c_parser_next_token_is (parser, CPP_MULT))
   {