/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/vec.h

Bug Summary

File:	build/gcc/vec.h
Warning:	line 827, column 3 Called C++ object pointer is null
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 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 cp -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/cp -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-STKh0H.plist -x c++ /home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c
/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c

→
1/* -*- C++ -*- Parser.
 Copyright (C) 2000-2021 Free Software Foundation, Inc.
 Written by Mark Mitchell <mark@codesourcery.com>.

 This file is part of GCC.

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

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

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

21#include "config.h"
22#define INCLUDE_UNIQUE_PTR
23#include "system.h"
24#include "coretypes.h"
25#include "cp-tree.h"
26#include "c-family/c-common.h"
27#include "timevar.h"
28#include "stringpool.h"
29#include "cgraph.h"
30#include "print-tree.h"
31#include "attribs.h"
32#include "trans-mem.h"
33#include "intl.h"
34#include "decl.h"
35#include "c-family/c-objc.h"
36#include "plugin.h"
37#include "tree-pretty-print.h"
38#include "parser.h"
39#include "gomp-constants.h"
40#include "omp-general.h"
41#include "omp-offload.h"
42#include "c-family/c-indentation.h"
43#include "context.h"
44#include "gcc-rich-location.h"
45#include "tree-iterator.h"
46#include "cp-name-hint.h"
47#include "memmodel.h"
48#include "c-family/known-headers.h"

50
51/* The lexer.  */

53/* The cp_lexer_* routines mediate between the lexer proper (in libcpp
 and c-lex.c) and the C++ parser.  */

56/* The various kinds of non integral constant we encounter. */
57enum non_integral_constant {
NIC_NONE,
/* floating-point literal */
NIC_FLOAT,
/* %<this%> */
NIC_THIS,
/* %<__FUNCTION__%> */
NIC_FUNC_NAME,
/* %<__PRETTY_FUNCTION__%> */
NIC_PRETTY_FUNC,
/* %<__func__%> */
NIC_C99_FUNC,
/* "%<va_arg%> */
NIC_VA_ARG,
/* a cast */
NIC_CAST,
/* %<typeid%> operator */
NIC_TYPEID,
/* non-constant compound literals */
NIC_NCC,
/* a function call */
NIC_FUNC_CALL,
/* an increment */
NIC_INC,
/* an decrement */
NIC_DEC,
/* an array reference */
NIC_ARRAY_REF,
/* %<->%> */
NIC_ARROW,
/* %<.%> */
NIC_POINT,
/* the address of a label */
NIC_ADDR_LABEL,
/* %<*%> */
NIC_STAR,
/* %<&%> */
NIC_ADDR,
/* %<++%> */
NIC_PREINCREMENT,
/* %<--%> */
NIC_PREDECREMENT,
/* %<new%> */
NIC_NEW,
/* %<delete%> */
NIC_DEL,
/* calls to overloaded operators */
NIC_OVERLOADED,
/* an assignment */
NIC_ASSIGNMENT,
/* a comma operator */
NIC_COMMA,
/* a call to a constructor */
NIC_CONSTRUCTOR,
/* a transaction expression */
NIC_TRANSACTION
113};

115/* The various kinds of errors about name-lookup failing. */
116enum name_lookup_error {
/* NULL */
NLE_NULL,
/* is not a type */
NLE_TYPE,
/* is not a class or namespace */
NLE_CXX98,
/* is not a class, namespace, or enumeration */
NLE_NOT_CXX98
125};

127/* The various kinds of required token */
128enum required_token {
RT_NONE,
RT_SEMICOLON,  /* ';' */
RT_OPEN_PAREN, /* '(' */
RT_CLOSE_BRACE, /* '}' */
RT_OPEN_BRACE,  /* '{' */
RT_CLOSE_SQUARE, /* ']' */
RT_OPEN_SQUARE,  /* '[' */
RT_COMMA, /* ',' */
RT_SCOPE, /* '::' */
RT_LESS, /* '<' */
RT_GREATER, /* '>' */
RT_EQ, /* '=' */
RT_ELLIPSIS, /* '...' */
RT_MULT, /* '*' */
RT_COMPL, /* '~' */
RT_COLON, /* ':' */
RT_COLON_SCOPE, /* ':' or '::' */
RT_CLOSE_PAREN, /* ')' */
RT_COMMA_CLOSE_PAREN, /* ',' or ')' */
RT_PRAGMA_EOL, /* end of line */
RT_NAME, /* identifier */

/* The type is CPP_KEYWORD */
RT_NEW, /* new */
RT_DELETE, /* delete */
RT_RETURN, /* return */
RT_WHILE, /* while */
RT_EXTERN, /* extern */
RT_STATIC_ASSERT, /* static_assert */
RT_DECLTYPE, /* decltype */
RT_OPERATOR, /* operator */
RT_CLASS, /* class */
RT_TEMPLATE, /* template */
RT_NAMESPACE, /* namespace */
RT_USING, /* using */
RT_ASM, /* asm */
RT_TRY, /* try */
RT_CATCH, /* catch */
RT_THROW, /* throw */
RT_AUTO, /* auto */
RT_LABEL, /* __label__ */
RT_AT_TRY, /* @try */
RT_AT_SYNCHRONIZED, /* @synchronized */
RT_AT_THROW, /* @throw */

RT_SELECT,  /* selection-statement */
RT_ITERATION, /* iteration-statement */
RT_JUMP, /* jump-statement */
RT_CLASS_KEY, /* class-key */
RT_CLASS_TYPENAME_TEMPLATE, /* class, typename, or template */
RT_TRANSACTION_ATOMIC, /* __transaction_atomic */
RT_TRANSACTION_RELAXED, /* __transaction_relaxed */
RT_TRANSACTION_CANCEL, /* __transaction_cancel */

RT_CO_YIELD /* co_yield */
184};

186/* RAII wrapper for parser->in_type_id_in_expr_p, setting it on creation and
 reverting it on destruction.  */

189class type_id_in_expr_sentinel
190{
cp_parser *parser;
bool saved;
193public:
type_id_in_expr_sentinel (cp_parser *parser, bool set = true)
  : parser (parser),
    saved (parser->in_type_id_in_expr_p)
{ parser->in_type_id_in_expr_p = set; }
~type_id_in_expr_sentinel ()
{ parser->in_type_id_in_expr_p = saved; }
200};

202/* Prototypes.  */

204static cp_lexer *cp_lexer_new_main
(void);
206static cp_lexer *cp_lexer_new_from_tokens
(cp_token_cache *tokens);
208static void cp_lexer_destroy
(cp_lexer *);
210static int cp_lexer_saving_tokens
(const cp_lexer *);
212static cp_token *cp_lexer_token_at
(cp_lexer *, cp_token_position);
214static void cp_lexer_get_preprocessor_token
(unsigned, cp_token *);
216static inline cp_token *cp_lexer_peek_token
(cp_lexer *);
218static cp_token *cp_lexer_peek_nth_token
(cp_lexer *, size_t);
220static inline bool cp_lexer_next_token_is
(cp_lexer *, enum cpp_ttype);
222static bool cp_lexer_next_token_is_not
(cp_lexer *, enum cpp_ttype);
224static bool cp_lexer_next_token_is_keyword
(cp_lexer *, enum rid);
226static cp_token *cp_lexer_consume_token
(cp_lexer *);
228static void cp_lexer_purge_token
(cp_lexer *);
230static void cp_lexer_purge_tokens_after
(cp_lexer *, cp_token_position);
232static void cp_lexer_save_tokens
(cp_lexer *);
234static void cp_lexer_commit_tokens
(cp_lexer *);
236static void cp_lexer_rollback_tokens
(cp_lexer *);
238static void cp_lexer_print_token
(FILE *, cp_token *);
240static inline bool cp_lexer_debugging_p
(cp_lexer *);
242static void cp_lexer_start_debugging
(cp_lexer *) ATTRIBUTE_UNUSED__attribute__ ((__unused__));
244static void cp_lexer_stop_debugging
(cp_lexer *) ATTRIBUTE_UNUSED__attribute__ ((__unused__));

247static cp_token_cache *cp_token_cache_new
(cp_token *, cp_token *);
249static tree cp_parser_late_noexcept_specifier
(cp_parser *, tree);
251static void noexcept_override_late_checks
(tree, tree);

254static void cp_parser_initial_pragma
(cp_token *);

257static bool cp_parser_omp_declare_reduction_exprs
(tree, cp_parser *);
259static void cp_finalize_oacc_routine
(cp_parser *, tree, bool);

262/* Manifest constants.  */
263#define CP_LEXER_BUFFER_SIZE((256 * 1024) / sizeof (cp_token)) ((256 * 1024) / sizeof (cp_token))
264#define CP_SAVED_TOKEN_STACK5 5

266/* Variables.  */

268/* The stream to which debugging output should be written.  */
269static FILE *cp_lexer_debug_stream;

271/* Nonzero if we are parsing an unevaluated operand: an operand to
 sizeof, typeof, or alignof.  */
273int cp_unevaluated_operand;

275/* Dump up to NUM tokens in BUFFER to FILE starting with token
 START_TOKEN.  If START_TOKEN is NULL, the dump starts with the
 first token in BUFFER.  If NUM is 0, dump all the tokens.  If
 CURR_TOKEN is set and it is one of the tokens in BUFFER, it will be
 highlighted by surrounding it in [[ ]].  */

281static void
282cp_lexer_dump_tokens (FILE *file, vec<cp_token, va_gc> *buffer,
      cp_token *start_token, unsigned num,
      cp_token *curr_token)
285{
unsigned i, nprinted;
cp_token *token;
bool do_print;

fprintf (file, "%u tokens\n", vec_safe_length (buffer));

if (buffer == NULL__null)
  return;

if (num == 0)
  num = buffer->length ();

if (start_token == NULL__null)
  start_token = buffer->address ();

if (start_token > buffer->address ())
  {
    cp_lexer_print_token (file, &(*buffer)[0]);
    fprintf (file, " ... ");
  }

do_print = false;
nprinted = 0;
for (i = 0; buffer->iterate (i, &token) && nprinted < num; i++)
  {
    if (token == start_token)
do_print = true;

    if (!do_print)
continue;

    nprinted++;
    if (token == curr_token)
fprintf (file, "[[");

    cp_lexer_print_token (file, token);

    if (token == curr_token)
fprintf (file, "]]");

    switch (token->type)
{
 case CPP_SEMICOLON:
 case CPP_OPEN_BRACE:
 case CPP_CLOSE_BRACE:
 case CPP_EOF:
   fputc ('\n', file);
   break;

 default:
   fputc (' ', file);
}
  }

if (i == num && i < buffer->length ())
  {
    fprintf (file, " ... ");
    cp_lexer_print_token (file, &buffer->last ());
  }

fprintf (file, "\n");
347}


350/* Dump all tokens in BUFFER to stderr.  */

352void
353cp_lexer_debug_tokens (vec<cp_token, va_gc> *buffer)
354{
cp_lexer_dump_tokens (stderrstderr, buffer, NULL__null, 0, NULL__null);
356}

358DEBUG_FUNCTION__attribute__ ((__used__)) void
359debug (vec<cp_token, va_gc> &ref)
360{
cp_lexer_dump_tokens (stderrstderr, &ref, NULL__null, 0, NULL__null);
362}

364DEBUG_FUNCTION__attribute__ ((__used__)) void
365debug (vec<cp_token, va_gc> *ptr)
366{
if (ptr)
  debug (*ptr);
else
  fprintf (stderrstderr, "<nil>\n");
371}


374/* Dump the cp_parser tree field T to FILE if T is non-NULL.  DESC is the
 description for T.  */

377static void
378cp_debug_print_tree_if_set (FILE *file, const char *desc, tree t)
379{
if (t)
  {
    fprintf (file, "%s: ", desc);
    print_node_brief (file, "", t, 0);
  }
385}


388/* Dump parser context C to FILE.  */

390static void
391cp_debug_print_context (FILE *file, cp_parser_context *c)
392{
const char *status_s[] = { "OK", "ERROR", "COMMITTED" };
fprintf (file, "{ status = %s, scope = ", status_s[c->status]);
print_node_brief (file, "", c->object_type, 0);
fprintf (file, "}\n");
397}


400/* Print the stack of parsing contexts to FILE starting with FIRST.  */

402static void
403cp_debug_print_context_stack (FILE *file, cp_parser_context *first)
404{
unsigned i;
cp_parser_context *c;

fprintf (file, "Parsing context stack:\n");
for (i = 0, c = first; c; c = c->next, i++)
  {
    fprintf (file, "\t#%u: ", i);
    cp_debug_print_context (file, c);
  }
414}


417/* Print the value of FLAG to FILE.  DESC is a string describing the flag.  */

419static void
420cp_debug_print_flag (FILE *file, const char *desc, bool flag)
421{
if (flag)
  fprintf (file, "%s: true\n", desc);
424}


427/* Print an unparsed function entry UF to FILE.  */

429static void
430cp_debug_print_unparsed_function (FILE *file, cp_unparsed_functions_entry *uf)
431{
unsigned i;
cp_default_arg_entry *default_arg_fn;
tree fn;

fprintf (file, "\tFunctions with default args:\n");
for (i = 0;
     vec_safe_iterate (uf->funs_with_default_args, i, &default_arg_fn);
     i++)
  {
    fprintf (file, "\t\tClass type: ");
    print_node_brief (file, "", default_arg_fn->class_type, 0);
    fprintf (file, "\t\tDeclaration: ");
    print_node_brief (file, "", default_arg_fn->decl, 0);
    fprintf (file, "\n");
  }

fprintf (file, "\n\tFunctions with definitions that require "
  "post-processing\n\t\t");
for (i = 0; vec_safe_iterate (uf->funs_with_definitions, i, &fn); i++)
  {
    print_node_brief (file, "", fn, 0);
    fprintf (file, " ");
  }
fprintf (file, "\n");

fprintf (file, "\n\tNon-static data members with initializers that require "
         "post-processing\n\t\t");
for (i = 0; vec_safe_iterate (uf->nsdmis, i, &fn); i++)
  {
    print_node_brief (file, "", fn, 0);
    fprintf (file, " ");
  }
fprintf (file, "\n");
465}


468/* Print the stack of unparsed member functions S to FILE.  */

470static void
471cp_debug_print_unparsed_queues (FILE *file,
		vec<cp_unparsed_functions_entry, va_gc> *s)
473{
unsigned i;
cp_unparsed_functions_entry *uf;

fprintf (file, "Unparsed functions\n");
for (i = 0; vec_safe_iterate (s, i, &uf); i++)
  {
    fprintf (file, "#%u:\n", i);
    cp_debug_print_unparsed_function (file, uf);
  }
483}


486/* Dump the tokens in a window of size WINDOW_SIZE around the next_token for
 the given PARSER.  If FILE is NULL, the output is printed on stderr. */

489static void
490cp_debug_parser_tokens (FILE *file, cp_parser *parser, int window_size)
491{
cp_token *next_token, *first_token, *start_token;

if (file == NULL__null)
  file = stderrstderr;

next_token = parser->lexer->next_token;
first_token = parser->lexer->buffer->address ();
start_token = (next_token > first_token + window_size / 2)
? next_token - window_size / 2
: first_token;
cp_lexer_dump_tokens (file, parser->lexer->buffer, start_token, window_size,
	next_token);
504}


507/* Dump debugging information for the given PARSER.  If FILE is NULL,
 the output is printed on stderr.  */

510void
511cp_debug_parser (FILE *file, cp_parser *parser)
512{
const size_t window_size = 20;
cp_token *token;
expanded_location eloc;

if (file == NULL__null)
  file = stderrstderr;

fprintf (file, "Parser state\n\n");
fprintf (file, "Number of tokens: %u\n",
  vec_safe_length (parser->lexer->buffer));
cp_debug_print_tree_if_set (file, "Lookup scope", parser->scope);
cp_debug_print_tree_if_set (file, "Object scope",
		     parser->object_scope);
cp_debug_print_tree_if_set (file, "Qualifying scope",
		     parser->qualifying_scope);
cp_debug_print_context_stack (file, parser->context);
cp_debug_print_flag (file, "Allow GNU extensions",
	      parser->allow_gnu_extensions_p);
cp_debug_print_flag (file, "'>' token is greater-than",
	      parser->greater_than_is_operator_p);
cp_debug_print_flag (file, "Default args allowed in current "
	      "parameter list", parser->default_arg_ok_p);
cp_debug_print_flag (file, "Parsing integral constant-expression",
	      parser->integral_constant_expression_p);
cp_debug_print_flag (file, "Allow non-constant expression in current "
	      "constant-expression",
	      parser->allow_non_integral_constant_expression_p);
cp_debug_print_flag (file, "Seen non-constant expression",
	      parser->non_integral_constant_expression_p);
cp_debug_print_flag (file, "Local names forbidden in current context",
	      (parser->local_variables_forbidden_p
	       & LOCAL_VARS_FORBIDDEN(1 << 0)));
cp_debug_print_flag (file, "'this' forbidden in current context",
	      (parser->local_variables_forbidden_p
	       & THIS_FORBIDDEN(1 << 1)));
cp_debug_print_flag (file, "In unbraced linkage specification",
	      parser->in_unbraced_linkage_specification_p);
cp_debug_print_flag (file, "Parsing a declarator",
	      parser->in_declarator_p);
cp_debug_print_flag (file, "In template argument list",
	      parser->in_template_argument_list_p);
cp_debug_print_flag (file, "Parsing an iteration statement",
	      parser->in_statement & IN_ITERATION_STMT2);
cp_debug_print_flag (file, "Parsing a switch statement",
	      parser->in_statement & IN_SWITCH_STMT1);
cp_debug_print_flag (file, "Parsing a structured OpenMP block",
	      parser->in_statement & IN_OMP_BLOCK4);
cp_debug_print_flag (file, "Parsing an OpenMP loop",
	      parser->in_statement & IN_OMP_FOR8);
cp_debug_print_flag (file, "Parsing an if statement",
	      parser->in_statement & IN_IF_STMT16);
cp_debug_print_flag (file, "Parsing a type-id in an expression "
	      "context", parser->in_type_id_in_expr_p);
cp_debug_print_flag (file, "String expressions should be translated "
	      "to execution character set",
	      parser->translate_strings_p);
cp_debug_print_flag (file, "Parsing function body outside of a "
	      "local class", parser->in_function_body);
cp_debug_print_flag (file, "Auto correct a colon to a scope operator",
	      parser->colon_corrects_to_scope_p);
cp_debug_print_flag (file, "Colon doesn't start a class definition",
	      parser->colon_doesnt_start_class_def_p);
if (parser->type_definition_forbidden_message)
  fprintf (file, "Error message for forbidden type definitions: %s %s\n",
    parser->type_definition_forbidden_message,
    parser->type_definition_forbidden_message_arg
    ? parser->type_definition_forbidden_message_arg : "<none>");
cp_debug_print_unparsed_queues (file, parser->unparsed_queues);
fprintf (file, "Number of class definitions in progress: %u\n",
  parser->num_classes_being_defined);
fprintf (file, "Number of template parameter lists for the current "
  "declaration: %u\n", parser->num_template_parameter_lists);
cp_debug_parser_tokens (file, parser, window_size);
token = parser->lexer->next_token;
fprintf (file, "Next token to parse:\n");
fprintf (file, "\tToken:  ");
cp_lexer_print_token (file, token);
eloc = expand_location (token->location);
fprintf (file, "\n\tFile:   %s\n", eloc.file);
fprintf (file, "\tLine:   %d\n", eloc.line);
fprintf (file, "\tColumn: %d\n", eloc.column);
594}

596DEBUG_FUNCTION__attribute__ ((__used__)) void
597debug (cp_parser &ref)
598{
cp_debug_parser (stderrstderr, &ref);
600}

602DEBUG_FUNCTION__attribute__ ((__used__)) void
603debug (cp_parser *ptr)
604{
if (ptr)
  debug (*ptr);
else
  fprintf (stderrstderr, "<nil>\n");
609}

611/* Allocate memory for a new lexer object and return it.  */

613static cp_lexer *
614cp_lexer_alloc (void)
615{
/* Allocate the memory.  */
cp_lexer *lexer = ggc_cleared_alloc<cp_lexer> ();

/* Initially we are not debugging.  */
lexer->debugging_p = false;

lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK5);

/* Create the buffer.  */
vec_alloc (lexer->buffer, CP_LEXER_BUFFER_SIZE((256 * 1024) / sizeof (cp_token)));

return lexer;
628}

630/* Create a new main C++ lexer, the lexer that gets tokens from the
 preprocessor.  */

633static cp_lexer *
634cp_lexer_new_main (void)
635{
cp_token token;

/* It's possible that parsing the first pragma will load a PCH file,
   which is a GC collection point.  So we have to do that before
   allocating any memory.  */
cp_lexer_get_preprocessor_token (0, &token);
cp_parser_initial_pragma (&token);
c_common_no_more_pch ();

cp_lexer *lexer = cp_lexer_alloc ();
/* Put the first token in the buffer.  */
cp_token *tok = lexer->buffer->quick_push (token);

uintptr_t filter = 0;
if (modules_p ())
  filter = module_token_cdtor (parse_in, filter);

/* Get the remaining tokens from the preprocessor.  */
while (tok->type != CPP_EOF)
  {
    if (filter)
/* Process the previous token.  */
module_token_lang (tok->type, tok->keyword, tok->u.value,
	   tok->location, filter);
    tok = vec_safe_push (lexer->buffer, cp_token ());
    cp_lexer_get_preprocessor_token (C_LEX_STRING_NO_JOIN2, tok);
  }

lexer->next_token = lexer->buffer->address ();
lexer->last_token = lexer->next_token
                    + lexer->buffer->length ()
      - 1;

if (lexer->buffer->length () != 1)
  {
    /* Set the EOF token's location to be the just after the previous
       token's range.  That way 'at-eof' diagnostics point at something
meaninful.  */
    auto range = get_range_from_loc (line_table, tok[-1].location);
    tok[0].location
= linemap_position_for_loc_and_offset (line_table, range.m_finish, 1);
  }

if (filter)
  module_token_cdtor (parse_in, filter);

/* Subsequent preprocessor diagnostics should use compiler
   diagnostic functions to get the compiler source location.  */
done_lexing = true;

maybe_check_all_macros (parse_in);

gcc_assert (!lexer->next_token->purged_p)((void)(!(!lexer->next_token->purged_p) ? fancy_abort (
"/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 688, __FUNCTION__), 0 : 0));
return lexer;
690}

692/* Create a new lexer whose token stream is primed with the tokens in
 CACHE.  When these tokens are exhausted, no new tokens will be read.  */

695static cp_lexer *
696cp_lexer_new_from_tokens (cp_token_cache *cache)
697{
cp_token *first = cache->first;
cp_token *last = cache->last;
cp_lexer *lexer = ggc_cleared_alloc<cp_lexer> ();

/* We do not own the buffer.  */
lexer->buffer = NULL__null;

/* Insert an EOF token.  */
lexer->saved_type = last->type;
lexer->saved_keyword = last->keyword;
last->type = CPP_EOF;
last->keyword = RID_MAX;

lexer->next_token = first;
lexer->last_token = last;

lexer->saved_tokens.create (CP_SAVED_TOKEN_STACK5);

/* Initially we are not debugging.  */
lexer->debugging_p = false;

gcc_assert (!lexer->next_token->purged_p((void)(!(!lexer->next_token->purged_p && !lexer
->last_token->purged_p) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 720, __FUNCTION__), 0 : 0))
     && !lexer->last_token->purged_p)((void)(!(!lexer->next_token->purged_p && !lexer
->last_token->purged_p) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 720, __FUNCTION__), 0 : 0));
return lexer;
722}

724/* Frees all resources associated with LEXER.  */

726static void
727cp_lexer_destroy (cp_lexer *lexer)
728{
if (lexer->buffer)
  vec_free (lexer->buffer);
else
  {
    /* Restore the token we overwrite with EOF.  */
    lexer->last_token->type = lexer->saved_type;
    lexer->last_token->keyword = lexer->saved_keyword;
  }
lexer->saved_tokens.release ();
ggc_free (lexer);
739}

741/* This needs to be set to TRUE before the lexer-debugging infrastructure can
 be used.  The point of this flag is to help the compiler to fold away calls
 to cp_lexer_debugging_p within this source file at compile time, when the
 lexer is not being debugged.  */

746#define LEXER_DEBUGGING_ENABLED_Pfalse false

748/* Returns nonzero if debugging information should be output.  */

750static inline bool
751cp_lexer_debugging_p (cp_lexer *lexer)
752{
if (!LEXER_DEBUGGING_ENABLED_Pfalse)
  return false;

return lexer->debugging_p;
757}


760static inline cp_token_position
761cp_lexer_token_position (cp_lexer *lexer, bool previous_p)
762{
return lexer->next_token - previous_p;
764}

766static inline cp_token *
767cp_lexer_token_at (cp_lexer * /*lexer*/, cp_token_position pos)
768{
return pos;
770}

772static inline void
773cp_lexer_set_token_position (cp_lexer *lexer, cp_token_position pos)
774{
lexer->next_token = cp_lexer_token_at (lexer, pos);
776}

778static inline cp_token_position
779cp_lexer_previous_token_position (cp_lexer *lexer)
780{
return cp_lexer_token_position (lexer, true);
782}

784static inline cp_token *
785cp_lexer_previous_token (cp_lexer *lexer)
786{
cp_token_position tp = cp_lexer_previous_token_position (lexer);

/* Skip past purged tokens.  */
while (tp->purged_p)
  {
    gcc_assert (tp != vec_safe_address (lexer->buffer))((void)(!(tp != vec_safe_address (lexer->buffer)) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 792, __FUNCTION__), 0 : 0));
    tp--;
  }

return cp_lexer_token_at (lexer, tp);
797}

799/* Same as above, but return NULL when the lexer doesn't own the token
 buffer or if the next_token is at the start of the token
 vector or if all previous tokens are purged.  */

803static cp_token *
804cp_lexer_safe_previous_token (cp_lexer *lexer)
805{
if (lexer->buffer
    && lexer->next_token != lexer->buffer->address ())
  {
    cp_token_position tp = cp_lexer_previous_token_position (lexer);

    /* Skip past purged tokens.  */
    while (tp->purged_p)
{
 if (tp == lexer->buffer->address ())
   return NULL__null;
 tp--;
}
    return cp_lexer_token_at (lexer, tp);
  }

return NULL__null;
822}

824/* Overload for make_location, taking the lexer to mean the location of the
 previous token.  */

827static inline location_t
828make_location (location_t caret, location_t start, cp_lexer *lexer)
829{
cp_token *t = cp_lexer_previous_token (lexer);
return make_location (caret, start, t->location);
832}

834/* Overload for make_location taking tokens instead of locations.  */

836static inline location_t
837make_location (cp_token *caret, cp_token *start, cp_token *end)
838{
return make_location (caret->location, start->location, end->location);
840}

842/* nonzero if we are presently saving tokens.  */

844static inline int
845cp_lexer_saving_tokens (const cp_lexer* lexer)
846{
return lexer->saved_tokens.length () != 0;
848}

850/* Store the next token from the preprocessor in *TOKEN.  Return true
 if we reach EOF.  If LEXER is NULL, assume we are handling an
 initial #pragma pch_preprocess, and thus want the lexer to return
 processed strings.  */

855static void
856cp_lexer_get_preprocessor_token (unsigned flags, cp_token *token)
857{
static int is_extern_c = 0;

 /* Get a new token from the preprocessor.  */
token->type
  = c_lex_with_flags (&token->u.value, &token->location, &token->flags,
	flags);
token->keyword = RID_MAX;
token->purged_p = false;
token->error_reported = false;
token->tree_check_p = false;
/* Usually never see a zero, but just in case ... */
token->main_source_p = line_table->depth <= 1;

/* On some systems, some header files are surrounded by an
   implicit extern "C" block.  Set a flag in the token if it
   comes from such a header.  */
is_extern_c += pending_lang_change;
pending_lang_change = 0;
token->implicit_extern_c = is_extern_c > 0;

/* Check to see if this token is a keyword.  */
if (token->type == CPP_NAME)
  {
    if (IDENTIFIER_KEYWORD_P (token->u.value)((!((tree_not_check2 (((tree_check ((token->u.value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 881, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 881, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_2)) & (!((tree_not_check2 (((tree_check ((token
->u.value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 881, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 881, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_1)) & ((tree_not_check2 (((tree_check ((token->
u.value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 881, __FUNCTION__, (IDENTIFIER_NODE)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 881, __FUNCTION__, (TREE_VEC), (SSA_NAME)))->base.u.bits
.lang_flag_0)))
{
 /* Mark this token as a keyword.  */
 token->type = CPP_KEYWORD;
 /* Record which keyword.  */
 token->keyword = C_RID_CODE (token->u.value)((enum rid) (((struct c_common_identifier *) (token->u.value
))->node.rid_code));
}
    else
{
        if (warn_cxx11_compatglobal_options.x_warn_cxx11_compat
            && C_RID_CODE (token->u.value)((enum rid) (((struct c_common_identifier *) (token->u.value
))->node.rid_code)) >= RID_FIRST_CXX11
            && C_RID_CODE (token->u.value)((enum rid) (((struct c_common_identifier *) (token->u.value
))->node.rid_code)) <= RID_LAST_CXX11)
          {
            /* Warn about the C++0x keyword (but still treat it as
               an identifier).  */
     warning_at (token->location, OPT_Wc__11_compat,
	  "identifier %qE is a keyword in C++11",
	  token->u.value);

            /* Clear out the C_RID_CODE so we don't warn about this
               particular identifier-turned-keyword again.  */
            C_SET_RID_CODE (token->u.value, RID_MAX)(((struct c_common_identifier *) (token->u.value))->node
.rid_code = (unsigned char) RID_MAX);
          }
 if (warn_cxx20_compatglobal_options.x_warn_cxx20_compat
     && C_RID_CODE (token->u.value)((enum rid) (((struct c_common_identifier *) (token->u.value
))->node.rid_code)) >= RID_FIRST_CXX20
     && C_RID_CODE (token->u.value)((enum rid) (((struct c_common_identifier *) (token->u.value
))->node.rid_code)) <= RID_LAST_CXX20)
   {
     /* Warn about the C++20 keyword (but still treat it as
 an identifier).  */
     warning_at (token->location, OPT_Wc__20_compat,
	  "identifier %qE is a keyword in C++20",
	  token->u.value);

     /* Clear out the C_RID_CODE so we don't warn about this
 particular identifier-turned-keyword again.  */
     C_SET_RID_CODE (token->u.value, RID_MAX)(((struct c_common_identifier *) (token->u.value))->node
.rid_code = (unsigned char) RID_MAX);
   }

 token->keyword = RID_MAX;
}
  }
else if (token->type == CPP_AT_NAME)
  {
    /* This only happens in Objective-C++; it must be a keyword.  */
    token->type = CPP_KEYWORD;
    switch (C_RID_CODE (token->u.value)((enum rid) (((struct c_common_identifier *) (token->u.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->u.value)((enum rid) (((struct c_common_identifier *) (token->u.value
))->node.rid_code));
}
  }
947}

949/* Update the globals input_location and the input file stack from TOKEN.  */
950static inline void
951cp_lexer_set_source_position_from_token (cp_token *token)
952{
input_location = token->location;
954}

956/* Update the globals input_location and the input file stack from LEXER.  */
957static inline void
958cp_lexer_set_source_position (cp_lexer *lexer)
959{
cp_token *token = cp_lexer_peek_token (lexer);
cp_lexer_set_source_position_from_token (token);
962}

964/* Return a pointer to the next token in the token stream, but do not
 consume it.  */

967static inline cp_token *
968cp_lexer_peek_token (cp_lexer *lexer)
969{
if (cp_lexer_debugging_p (lexer))
  {
    fputs ("cp_lexer: peeking at token: ", cp_lexer_debug_stream);
    cp_lexer_print_token (cp_lexer_debug_stream, lexer->next_token);
    putc ('\n', cp_lexer_debug_stream);
  }
return lexer->next_token;
977}

979/* Return true if the next token has the indicated TYPE.  */

981static inline bool
982cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type)
983{
return cp_lexer_peek_token (lexer)->type == type;
7
←
Assuming 'type' is equal to field 'type'→
8
←
Returning the value 1, which participates in a condition later→
20
←
Assuming 'type' is not equal to field 'type'→
21
←
Returning zero, which participates in a condition later→
32
←
Assuming 'type' is not equal to field 'type'→
33
←
Returning zero, which participates in a condition later→
44
←
Assuming 'type' is equal to field 'type'→
45
←
Returning the value 1, which participates in a condition later→
985}

987/* Return true if the next token does not have the indicated TYPE.  */

989static inline bool
990cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type)
991{
return !cp_lexer_next_token_is (lexer, type);
19
←
Calling 'cp_lexer_next_token_is'→
22
←
Returning from 'cp_lexer_next_token_is'→
23
←
Returning the value 1, which participates in a condition later→
31
←
Calling 'cp_lexer_next_token_is'→
34
←
Returning from 'cp_lexer_next_token_is'→
35
←
Returning the value 1, which participates in a condition later→
993}

995/* Return true if the next token is the indicated KEYWORD.  */

997static inline bool
998cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword)
999{
return cp_lexer_peek_token (lexer)->keyword == keyword;
1001}

1003static inline bool
1004cp_lexer_nth_token_is (cp_lexer* lexer, size_t n, enum cpp_ttype type)
1005{
return cp_lexer_peek_nth_token (lexer, n)->type == type;
1007}

1009static inline bool
1010cp_lexer_nth_token_is_keyword (cp_lexer* lexer, size_t n, enum rid keyword)
1011{
return cp_lexer_peek_nth_token (lexer, n)->keyword == keyword;
1013}

1015/* Return true if KEYWORD can start a decl-specifier.  */

1017bool
1018cp_keyword_starts_decl_specifier_p (enum rid keyword)
1019{
switch (keyword)
  {
    /* auto specifier: storage-class-specifier in C++,
       simple-type-specifier in C++0x.  */
  case RID_AUTO:
    /* Storage classes.  */
  case RID_REGISTER:
  case RID_STATIC:
  case RID_EXTERN:
  case RID_MUTABLE:
  case RID_THREAD:
    /* Elaborated type specifiers.  */
  case RID_ENUM:
  case RID_CLASS:
  case RID_STRUCT:
  case RID_UNION:
  case RID_TYPENAME:
    /* Simple type specifiers.  */
  case RID_CHAR:
  case RID_CHAR8:
  case RID_CHAR16:
  case RID_CHAR32:
  case RID_WCHAR:
  case RID_BOOL:
  case RID_SHORT:
  case RID_INT:
  case RID_LONG:
  case RID_SIGNED:
  case RID_UNSIGNED:
  case RID_FLOAT:
  case RID_DOUBLE:
  case RID_VOID:
    /* GNU extensions.  */
  case RID_ATTRIBUTE:
  case RID_TYPEOF:
    /* C++11 extensions.  */
  case RID_DECLTYPE:
  case RID_UNDERLYING_TYPE:
  case RID_CONSTEXPR:
    /* C++20 extensions.  */
  case RID_CONSTINIT:
  case RID_CONSTEVAL:
    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;
  }
1071}

1073/* Return true if the next token is a keyword for a decl-specifier.  */

1075static bool
1076cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer)
1077{
cp_token *token;

token = cp_lexer_peek_token (lexer);
return cp_keyword_starts_decl_specifier_p (token->keyword);
1082}

1084/* Returns TRUE iff the token T begins a decltype type.  */

1086static bool
1087token_is_decltype (cp_token *t)
1088{
return (t->keyword == RID_DECLTYPE
 || t->type == CPP_DECLTYPE((enum cpp_ttype) (((enum cpp_ttype) (((enum cpp_ttype) (CPP_KEYWORD
 + 1)) + 1)) + 1)));
1091}

1093/* Returns TRUE iff the next token begins a decltype type.  */

1095static bool
1096cp_lexer_next_token_is_decltype (cp_lexer *lexer)
1097{
cp_token *t = cp_lexer_peek_token (lexer);
return token_is_decltype (t);
1100}

1102/* Called when processing a token with tree_check_value; perform or defer the
 associated checks and return the value.  */

1105static tree
1106saved_checks_value (struct tree_check *check_value)
1107{
/* Perform any access checks that were deferred.  */
vec<deferred_access_check, va_gc> *checks;
deferred_access_check *chk;
checks = check_value->checks;
if (checks)
  {
    int i;
    FOR_EACH_VEC_SAFE_ELT (checks, i, chk)for (i = 0; vec_safe_iterate ((checks), (i), &(chk)); ++(
i))
perform_or_defer_access_check (chk->binfo,
		       chk->decl,
		       chk->diag_decl, tf_warning_or_error);
  }
/* Return the stored value.  */
return check_value->value;
1122}

1124/* Return a pointer to the Nth token in the token stream.  If N is 1,
 then this is precisely equivalent to cp_lexer_peek_token (except
 that it is not inline).  One would like to disallow that case, but
 there is one case (cp_parser_nth_token_starts_template_id) where
 the caller passes a variable for N and it might be 1.  */

1130static cp_token *
1131cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n)
1132{
cp_token *token;

/* 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/cp/parser.c"
, 1136, __FUNCTION__), 0 : 0));

if (cp_lexer_debugging_p (lexer))
  fprintf (cp_lexer_debug_stream,
    "cp_lexer: peeking ahead %ld at token: ", (long)n);

--n;
token = lexer->next_token;
while (n && token->type != CPP_EOF)
  {
    ++token;
    if (!token->purged_p)
--n;
  }

if (cp_lexer_debugging_p (lexer))
  {
    cp_lexer_print_token (cp_lexer_debug_stream, token);
    putc ('\n', cp_lexer_debug_stream);
  }

return token;
1158}

1160/* Return the next token, and advance the lexer's next_token pointer
 to point to the next non-purged token.  */

1163static cp_token *
1164cp_lexer_consume_token (cp_lexer* lexer)
1165{
cp_token *token = lexer->next_token;

do
  {
    gcc_assert (token->type != CPP_EOF)((void)(!(token->type != CPP_EOF) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 1170, __FUNCTION__), 0 : 0));
    lexer->next_token++;
  }
while (lexer->next_token->purged_p);

cp_lexer_set_source_position_from_token (token);

/* Provide debugging output.  */
if (cp_lexer_debugging_p (lexer))
  {
    fputs ("cp_lexer: consuming token: ", cp_lexer_debug_stream);
    cp_lexer_print_token (cp_lexer_debug_stream, token);
    putc ('\n', cp_lexer_debug_stream);
  }

return token;
1186}

1188/* Permanently remove the next token from the token stream, and
 advance the next_token pointer to refer to the next non-purged
 token.  */

1192static void
1193cp_lexer_purge_token (cp_lexer *lexer)
1194{
cp_token *tok = lexer->next_token;

gcc_assert (tok->type != CPP_EOF)((void)(!(tok->type != CPP_EOF) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 1197, __FUNCTION__), 0 : 0));
tok->purged_p = true;
tok->location = UNKNOWN_LOCATION((location_t) 0);
tok->u.value = NULL_TREE(tree) __null;
tok->keyword = RID_MAX;

do
  tok++;
while (tok->purged_p);
lexer->next_token = tok;
1207}

1209/* Permanently remove all tokens after TOK, up to, but not
 including, the token that will be returned next by
 cp_lexer_peek_token.  */

1213static void
1214cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok)
1215{
cp_token *peek = lexer->next_token;

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

for (tok++; tok != peek; tok++)
  {
    tok->purged_p = true;
    tok->location = UNKNOWN_LOCATION((location_t) 0);
    tok->u.value = NULL_TREE(tree) __null;
    tok->keyword = RID_MAX;
  }
1227}

1229/* Begin saving tokens.  All tokens consumed after this point will be
 preserved.  */

1232static void
1233cp_lexer_save_tokens (cp_lexer* lexer)
1234{
/* Provide debugging output.  */
if (cp_lexer_debugging_p (lexer))
  fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n");

lexer->saved_tokens.safe_push (lexer->next_token);
1240}

1242/* Commit to the portion of the token stream most recently saved.  */

1244static void
1245cp_lexer_commit_tokens (cp_lexer* lexer)
1246{
/* Provide debugging output.  */
if (cp_lexer_debugging_p (lexer))
  fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n");

lexer->saved_tokens.pop ();
1252}

1254/* Return all tokens saved since the last call to cp_lexer_save_tokens
 to the token stream.  Stop saving tokens.  */

1257static void
1258cp_lexer_rollback_tokens (cp_lexer* lexer)
1259{
/* Provide debugging output.  */
if (cp_lexer_debugging_p (lexer))
  fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n");

lexer->next_token = lexer->saved_tokens.pop ();
1265}

1267/* RAII wrapper around the above functions, with sanity checking.  Creating
 a variable saves tokens, which are committed when the variable is
 destroyed unless they are explicitly rolled back by calling the rollback
 member function.  */

1272struct saved_token_sentinel
1273{
cp_lexer *lexer;
unsigned len;
bool commit;
saved_token_sentinel(cp_lexer *lexer): lexer(lexer), commit(true)
{
  len = lexer->saved_tokens.length ();
  cp_lexer_save_tokens (lexer);
}
void rollback ()
{
  cp_lexer_rollback_tokens (lexer);
  commit = false;
}
~saved_token_sentinel()
{
  if (commit)
    cp_lexer_commit_tokens (lexer);
  gcc_assert (lexer->saved_tokens.length () == len)((void)(!(lexer->saved_tokens.length () == len) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 1291, __FUNCTION__), 0 : 0));
}
1293};

1295/* Print a representation of the TOKEN on the STREAM.  */

1297static void
1298cp_lexer_print_token (FILE * stream, cp_token *token)
1299{
/* We don't use cpp_type2name here because the parser defines
   a few tokens of its own.  */
static const char *const token_names[] = {
  /* cpplib-defined token types */
1304#define OP(e, s) #e,
1305#define TK(e, s) #e,
  TTYPE_TABLEOP(EQ, "=") OP(NOT, "!") OP(GREATER, ">") OP(LESS, "<")
 OP(PLUS, "+") OP(MINUS, "-") OP(MULT, "*") OP(DIV, "/") OP(MOD
, "%") OP(AND, "&") OP(OR, "|") OP(XOR, "^") OP(RSHIFT, ">>"
) OP(LSHIFT, "<<") OP(COMPL, "~") OP(AND_AND, "&&"
) OP(OR_OR, "||") OP(QUERY, "?") OP(COLON, ":") OP(COMMA, ","
) OP(OPEN_PAREN, "(") OP(CLOSE_PAREN, ")") TK((-1), NONE) OP(
EQ_EQ, "==") OP(NOT_EQ, "!=") OP(GREATER_EQ, ">=") OP(LESS_EQ
, "<=") OP(SPACESHIP, "<=>") OP(PLUS_EQ, "+=") OP(MINUS_EQ
, "-=") OP(MULT_EQ, "*=") OP(DIV_EQ, "/=") OP(MOD_EQ, "%=") OP
(AND_EQ, "&=") OP(OR_EQ, "|=") OP(XOR_EQ, "^=") OP(RSHIFT_EQ
, ">>=") OP(LSHIFT_EQ, "<<=") OP(HASH, "#") OP(PASTE
, "##") OP(OPEN_SQUARE, "[") OP(CLOSE_SQUARE, "]") OP(OPEN_BRACE
, "{") OP(CLOSE_BRACE, "}") OP(SEMICOLON, ";") OP(ELLIPSIS, "..."
) OP(PLUS_PLUS, "++") OP(MINUS_MINUS, "--") OP(DEREF, "->"
) OP(DOT, ".") OP(SCOPE, "::") OP(DEREF_STAR, "->*") OP(DOT_STAR
, ".*") OP(ATSIGN, "@") TK(NAME, IDENT) TK(AT_NAME, IDENT) TK
(NUMBER, LITERAL) TK(CHAR, LITERAL) TK(WCHAR, LITERAL) TK(CHAR16
, LITERAL) TK(CHAR32, LITERAL) TK(UTF8CHAR, LITERAL) TK(OTHER
, LITERAL) TK(STRING, LITERAL) TK(WSTRING, LITERAL) TK(STRING16
, LITERAL) TK(STRING32, LITERAL) TK(UTF8STRING, LITERAL) TK(OBJC_STRING
, LITERAL) TK(HEADER_NAME, LITERAL) TK(CHAR_USERDEF, LITERAL)
 TK(WCHAR_USERDEF, LITERAL) TK(CHAR16_USERDEF, LITERAL) TK(CHAR32_USERDEF
, LITERAL) TK(UTF8CHAR_USERDEF, LITERAL) TK(STRING_USERDEF, LITERAL
) TK(WSTRING_USERDEF, LITERAL) TK(STRING16_USERDEF, LITERAL) TK
(STRING32_USERDEF, LITERAL) TK(UTF8STRING_USERDEF,LITERAL) TK
(COMMENT, LITERAL) TK(MACRO_ARG, NONE) TK(PRAGMA, NONE) TK(PRAGMA_EOL
, NONE) TK(PADDING, NONE)
1307#undef OP
1308#undef TK
  /* C++ parser token types - see "Manifest constants", above.  */
  "KEYWORD",
  "TEMPLATE_ID",
  "NESTED_NAME_SPECIFIER",
};

/* For some tokens, print the associated data.  */
switch (token->type)
  {
  case CPP_KEYWORD:
    /* Some keywords have a value that is not an IDENTIFIER_NODE.
For example, `struct' is mapped to an INTEGER_CST.  */
    if (!identifier_p (token->u.value))
break;
    /* fall through */
  case CPP_NAME:
    fputs (IDENTIFIER_POINTER (token->u.value)((const char *) (tree_check ((token->u.value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 1325, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
), stream);
    break;

  case CPP_STRING:
  case CPP_STRING16:
  case CPP_STRING32:
  case CPP_WSTRING:
  case CPP_UTF8STRING:
    fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value)((const char *)((tree_check ((token->u.value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 1333, __FUNCTION__, (STRING_CST)))->string.str)));
    break;

  case CPP_NUMBER:
    print_generic_expr (stream, token->u.value);
    break;

  default:
    /* If we have a name for the token, print it out.  Otherwise, we
simply give the numeric code.  */
    if (token->type < ARRAY_SIZE(token_names)(sizeof (token_names) / sizeof ((token_names)[0])))
fputs (token_names[token->type], stream);
    else
fprintf (stream, "[%d]", token->type);
    break;
  }
1349}

1351DEBUG_FUNCTION__attribute__ ((__used__)) void
1352debug (cp_token &ref)
1353{
cp_lexer_print_token (stderrstderr, &ref);
fprintf (stderrstderr, "\n");
1356}

1358DEBUG_FUNCTION__attribute__ ((__used__)) void
1359debug (cp_token *ptr)
1360{
if (ptr)
  debug (*ptr);
else
  fprintf (stderrstderr, "<nil>\n");
1365}


1368/* Start emitting debugging information.  */

1370static void
1371cp_lexer_start_debugging (cp_lexer* lexer)
1372{
if (!LEXER_DEBUGGING_ENABLED_Pfalse)
  fatal_error (input_location,
 "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true");

lexer->debugging_p = true;
cp_lexer_debug_stream = stderrstderr;
1379}

1381/* Stop emitting debugging information.  */

1383static void
1384cp_lexer_stop_debugging (cp_lexer* lexer)
1385{
if (!LEXER_DEBUGGING_ENABLED_Pfalse)
  fatal_error (input_location,
 "%<LEXER_DEBUGGING_ENABLED_P%> is not set to true");

lexer->debugging_p = false;
cp_lexer_debug_stream = NULL__null;
1392}

1394/* Create a new cp_token_cache, representing a range of tokens.  */

1396static cp_token_cache *
1397cp_token_cache_new (cp_token *first, cp_token *last)
1398{
cp_token_cache *cache = ggc_alloc<cp_token_cache> ();
cache->first = first;
cache->last = last;
return cache;
1403}

1405/* Diagnose if #pragma omp declare simd isn't followed immediately
 by function declaration or definition.  */

1408static inline void
1409cp_ensure_no_omp_declare_simd (cp_parser *parser)
1410{
if (parser->omp_declare_simd && !parser->omp_declare_simd->error_seen)
  {
    error ("%<#pragma omp declare %s%> not immediately followed by "
    "function declaration or definition",
    parser->omp_declare_simd->variant_p ? "variant" : "simd");
    parser->omp_declare_simd = NULL__null;
  }
1418}

1420/* Finalize #pragma omp declare simd clauses after FNDECL has been parsed,
 and put that into "omp declare simd" attribute.  */

1423static inline void
1424cp_finalize_omp_declare_simd (cp_parser *parser, tree fndecl)
1425{
if (__builtin_expect (parser->omp_declare_simd != NULL__null, 0))
  {
    if (fndecl == error_mark_nodeglobal_trees[TI_ERROR_MARK])
{
 parser->omp_declare_simd = NULL__null;
 return;
}
    if (TREE_CODE (fndecl)((enum tree_code) (fndecl)->base.code) != FUNCTION_DECL)
{
 cp_ensure_no_omp_declare_simd (parser);
 return;
}
  }
1439}

1441/* Diagnose if #pragma acc routine isn't followed immediately by function
 declaration or definition.  */

1444static inline void
1445cp_ensure_no_oacc_routine (cp_parser *parser)
1446{
if (parser->oacc_routine && !parser->oacc_routine->error_seen)
  {
    error_at (parser->oacc_routine->loc,
"%<#pragma acc routine%> not immediately followed by "
"function declaration or definition");
    parser->oacc_routine = NULL__null;
  }
1454}
1455
1456/* Decl-specifiers.  */

1458/* Set *DECL_SPECS to represent an empty decl-specifier-seq.  */

1460static void
1461clear_decl_specs (cp_decl_specifier_seq *decl_specs)
1462{
memset (decl_specs, 0, sizeof (cp_decl_specifier_seq));
1464}

1466/* Declarators.  */

1468/* Nothing other than the parser should be creating declarators;
 declarators are a semi-syntactic representation of C++ entities.
 Other parts of the front end that need to create entities (like
 VAR_DECLs or FUNCTION_DECLs) should do that directly.  */

1473static cp_declarator *make_call_declarator
(cp_declarator *, tree, cp_cv_quals, cp_virt_specifiers, cp_ref_qualifier,
 tree, tree, tree, tree, location_t);
1476static cp_declarator *make_array_declarator
(cp_declarator *, tree);
1478static cp_declarator *make_pointer_declarator
(cp_cv_quals, cp_declarator *, tree);
1480static cp_declarator *make_reference_declarator
(cp_cv_quals, cp_declarator *, bool, tree);
1482static cp_declarator *make_ptrmem_declarator
(cp_cv_quals, tree, cp_declarator *, tree);

1485/* An erroneous declarator.  */
1486static cp_declarator *cp_error_declarator;

1488/* The obstack on which declarators and related data structures are
 allocated.  */
1490static struct obstack declarator_obstack;

1492/* Alloc BYTES from the declarator memory pool.  */

1494static inline void *
1495alloc_declarator (size_t bytes)
1496{
return obstack_alloc (&declarator_obstack, bytes)__extension__ ({ struct obstack *__h = (&declarator_obstack
); __extension__ ({ struct obstack *__o = (__h); size_t __len
 = ((bytes)); 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; }); });
1498}

1500/* Allocate a declarator of the indicated KIND.  Clear fields that are
 common to all declarators.  */

1503static cp_declarator *
1504make_declarator (cp_declarator_kind kind)
1505{
cp_declarator *declarator;

declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator));
declarator->kind = kind;
declarator->parenthesized = UNKNOWN_LOCATION((location_t) 0);
declarator->attributes = NULL_TREE(tree) __null;
declarator->std_attributes = NULL_TREE(tree) __null;
declarator->declarator = NULL__null;
declarator->parameter_pack_p = false;
declarator->id_loc = UNKNOWN_LOCATION((location_t) 0);

return declarator;
1518}

1520/* Make a declarator for a generalized identifier.  If
 QUALIFYING_SCOPE is non-NULL, the identifier is
 QUALIFYING_SCOPE::UNQUALIFIED_NAME; otherwise, it is just
 UNQUALIFIED_NAME.  SFK indicates the kind of special function this
 is, if any.   */

1526static cp_declarator *
1527make_id_declarator (tree qualifying_scope, tree unqualified_name,
    special_function_kind sfk, location_t id_location)
1529{
cp_declarator *declarator;

/* It is valid to write:

     class C { void f(); };
     typedef C D;
     void D::f();

   The standard is not clear about whether `typedef const C D' is
   legal; as of 2002-09-15 the committee is considering that
   question.  EDG 3.0 allows that syntax.  Therefore, we do as
   well.  */
if (qualifying_scope && TYPE_P (qualifying_scope)(tree_code_type[(int) (((enum tree_code) (qualifying_scope)->
base.code))] == tcc_type))
  qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope)((tree_class_check ((qualifying_scope), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 1543, __FUNCTION__))->type_common.main_variant);

gcc_assert (identifier_p (unqualified_name)((void)(!(identifier_p (unqualified_name) || ((enum tree_code
) (unqualified_name)->base.code) == BIT_NOT_EXPR || ((enum
 tree_code) (unqualified_name)->base.code) == TEMPLATE_ID_EXPR
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 1547, __FUNCTION__), 0 : 0))
     || TREE_CODE (unqualified_name) == BIT_NOT_EXPR((void)(!(identifier_p (unqualified_name) || ((enum tree_code
) (unqualified_name)->base.code) == BIT_NOT_EXPR || ((enum
 tree_code) (unqualified_name)->base.code) == TEMPLATE_ID_EXPR
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 1547, __FUNCTION__), 0 : 0))
     || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR)((void)(!(identifier_p (unqualified_name) || ((enum tree_code
) (unqualified_name)->base.code) == BIT_NOT_EXPR || ((enum
 tree_code) (unqualified_name)->base.code) == TEMPLATE_ID_EXPR
) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 1547, __FUNCTION__), 0 : 0));

declarator = make_declarator (cdk_id);
declarator->u.id.qualifying_scope = qualifying_scope;
declarator->u.id.unqualified_name = unqualified_name;
declarator->u.id.sfk = sfk;
declarator->id_loc = id_location;

return declarator;
1556}

1558/* Make a declarator for a pointer to TARGET.  CV_QUALIFIERS is a list
 of modifiers such as const or volatile to apply to the pointer
 type, represented as identifiers.  ATTRIBUTES represent the attributes that
 appertain to the pointer or reference.  */

1563cp_declarator *
1564make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
	 tree attributes)
1566{
cp_declarator *declarator;

declarator = make_declarator (cdk_pointer);
declarator->declarator = target;
declarator->u.pointer.qualifiers = cv_qualifiers;
declarator->u.pointer.class_type = NULL_TREE(tree) __null;
if (target)
  {
    declarator->id_loc = target->id_loc;
    declarator->parameter_pack_p = target->parameter_pack_p;
    target->parameter_pack_p = false;
  }
else
  declarator->parameter_pack_p = false;

declarator->std_attributes = attributes;

return declarator;
1585}

1587/* Like make_pointer_declarator -- but for references.  ATTRIBUTES
 represent the attributes that appertain to the pointer or
 reference.  */

1591cp_declarator *
1592make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target,
	   bool rvalue_ref, tree attributes)
1594{
cp_declarator *declarator;

declarator = make_declarator (cdk_reference);
declarator->declarator = target;
declarator->u.reference.qualifiers = cv_qualifiers;
declarator->u.reference.rvalue_ref = rvalue_ref;
if (target)
  {
    declarator->id_loc = target->id_loc;
    declarator->parameter_pack_p = target->parameter_pack_p;
    target->parameter_pack_p = false;
  }
else
  declarator->parameter_pack_p = false;

declarator->std_attributes = attributes;

return declarator;
1613}

1615/* Like make_pointer_declarator -- but for a pointer to a non-static
 member of CLASS_TYPE.  ATTRIBUTES represent the attributes that
 appertain to the pointer or reference.  */

1619cp_declarator *
1620make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type,
	cp_declarator *pointee,
	tree attributes)
1623{
cp_declarator *declarator;

declarator = make_declarator (cdk_ptrmem);
declarator->declarator = pointee;
declarator->u.pointer.qualifiers = cv_qualifiers;
declarator->u.pointer.class_type = class_type;

if (pointee)
  {
    declarator->parameter_pack_p = pointee->parameter_pack_p;
    pointee->parameter_pack_p = false;
  }
else
  declarator->parameter_pack_p = false;

declarator->std_attributes = attributes;

return declarator;
1642}

1644/* Make a declarator for the function given by TARGET, with the
 indicated PARMS.  The CV_QUALIFIERS apply to the function, as in
 "const"-qualified member function.  The EXCEPTION_SPECIFICATION
 indicates what exceptions can be thrown.  */

1649cp_declarator *
1650make_call_declarator (cp_declarator *target,
      tree parms,
      cp_cv_quals cv_qualifiers,
      cp_virt_specifiers virt_specifiers,
      cp_ref_qualifier ref_qualifier,
      tree tx_qualifier,
      tree exception_specification,
      tree late_return_type,
      tree requires_clause,
      location_t parens_loc)
1660{
cp_declarator *declarator;

declarator = make_declarator (cdk_function);
declarator->declarator = target;
declarator->u.function.parameters = parms;
declarator->u.function.qualifiers = cv_qualifiers;
declarator->u.function.virt_specifiers = virt_specifiers;
declarator->u.function.ref_qualifier = ref_qualifier;
declarator->u.function.tx_qualifier = tx_qualifier;
declarator->u.function.exception_specification = exception_specification;
declarator->u.function.late_return_type = late_return_type;
declarator->u.function.requires_clause = requires_clause;
declarator->u.function.parens_loc = parens_loc;
if (target)
  {
    declarator->id_loc = target->id_loc;
    declarator->parameter_pack_p = target->parameter_pack_p;
    target->parameter_pack_p = false;
  }
else
  declarator->parameter_pack_p = false;

return declarator;
1684}

1686/* Make a declarator for an array of BOUNDS elements, each of which is
 defined by ELEMENT.  */

1689cp_declarator *
1690make_array_declarator (cp_declarator *element, tree bounds)
1691{
cp_declarator *declarator;

declarator = make_declarator (cdk_array);
declarator->declarator = element;
declarator->u.array.bounds = bounds;
if (element)
  {
    declarator->id_loc = element->id_loc;
    declarator->parameter_pack_p = element->parameter_pack_p;
    element->parameter_pack_p = false;
  }
else
  declarator->parameter_pack_p = false;

return declarator;
1707}

1709/* Determine whether the declarator we've seen so far can be a
 parameter pack, when followed by an ellipsis.  */
1711static bool
1712declarator_can_be_parameter_pack (cp_declarator *declarator)
1713{
if (declarator && declarator->parameter_pack_p)
  /* We already saw an ellipsis.  */
  return false;

/* Search for a declarator name, or any other declarator that goes
   after the point where the ellipsis could appear in a parameter
   pack. If we find any of these, then this declarator cannot be
   made into a parameter pack.  */
bool found = false;
while (declarator && !found)
  {
    switch ((int)declarator->kind)
{
case cdk_id:
case cdk_array:
case cdk_decomp:
 found = true;
 break;

case cdk_error:
 return true;

default:
 declarator = declarator->declarator;
 break;
}
  }

return !found;
1743}

1745cp_parameter_declarator *no_parameters;

1747/* Create a parameter declarator with the indicated DECL_SPECIFIERS,
 DECLARATOR and DEFAULT_ARGUMENT.  */

1750cp_parameter_declarator *
1751make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers,
	   cp_declarator *declarator,
	   tree default_argument,
	   location_t loc,
	   bool template_parameter_pack_p = false)
1756{
cp_parameter_declarator *parameter;

parameter = ((cp_parameter_declarator *)
      alloc_declarator (sizeof (cp_parameter_declarator)));
parameter->next = NULL__null;
if (decl_specifiers)
  parameter->decl_specifiers = *decl_specifiers;
else
  clear_decl_specs (&parameter->decl_specifiers);
parameter->declarator = declarator;
parameter->default_argument = default_argument;
parameter->template_parameter_pack_p = template_parameter_pack_p;
parameter->loc = loc;

return parameter;
1772}

1774/* Returns true iff DECLARATOR  is a declaration for a function.  */

1776static bool
1777function_declarator_p (const cp_declarator *declarator)
1778{
while (declarator)
  {
    if (declarator->kind == cdk_function
 && declarator->declarator->kind == cdk_id)
return true;
    if (declarator->kind == cdk_id
 || declarator->kind == cdk_decomp
 || declarator->kind == cdk_error)
return false;
    declarator = declarator->declarator;
  }
return false;
1791}

1793/* The parser.  */

1795/* Overview
 --------

 A cp_parser parses the token stream as specified by the C++
 grammar.  Its job is purely parsing, not semantic analysis.  For
 example, the parser breaks the token stream into declarators,
 expressions, statements, and other similar syntactic constructs.
 It does not check that the types of the expressions on either side
 of an assignment-statement are compatible, or that a function is
 not declared with a parameter of type `void'.

 The parser invokes routines elsewhere in the compiler to perform
 semantic analysis and to build up the abstract syntax tree for the
 code processed.

 The parser (and the template instantiation code, which is, in a
 way, a close relative of parsing) are the only parts of the
 compiler that should be calling push_scope and pop_scope, or
 related functions.  The parser (and template instantiation code)
 keeps track of what scope is presently active; everything else
 should simply honor that.  (The code that generates static
 initializers may also need to set the scope, in order to check
 access control correctly when emitting the initializers.)

 Methodology
 -----------

 The parser is of the standard recursive-descent variety.  Upcoming
 tokens in the token stream are examined in order to determine which
 production to use when parsing a non-terminal.  Some C++ constructs
 require arbitrary look ahead to disambiguate.  For example, it is
 impossible, in the general case, to tell whether a statement is an
 expression or declaration without scanning the entire statement.
 Therefore, the parser is capable of "parsing tentatively."  When the
 parser is not sure what construct comes next, it enters this mode.
 Then, while we attempt to parse the construct, the parser queues up
 error messages, rather than issuing them immediately, and saves the
 tokens it consumes.  If the construct is parsed successfully, the
 parser "commits", i.e., it issues any queued error messages and
 the tokens that were being preserved are permanently discarded.
 If, however, the construct is not parsed successfully, the parser
 rolls back its state completely so that it can resume parsing using
 a different alternative.

 Future Improvements
 -------------------

 The performance of the parser could probably be improved substantially.
 We could often eliminate the need to parse tentatively by looking ahead
 a little bit.  In some places, this approach might not entirely eliminate
 the need to parse tentatively, but it might still speed up the average
 case.  */

1848/* Flags that are passed to some parsing functions.  These values can
 be bitwise-ored together.  */

1851enum
1852{
/* No flags.  */
CP_PARSER_FLAGS_NONE = 0x0,
/* The construct is optional.  If it is not present, then no error
   should be issued.  */
CP_PARSER_FLAGS_OPTIONAL = 0x1,
/* When parsing a type-specifier, treat user-defined type-names
   as non-type identifiers.  */
CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2,
/* When parsing a type-specifier, do not try to parse a class-specifier
   or enum-specifier.  */
CP_PARSER_FLAGS_NO_TYPE_DEFINITIONS = 0x4,
/* When parsing a decl-specifier-seq, only allow type-specifier or
   constexpr.  */
CP_PARSER_FLAGS_ONLY_TYPE_OR_CONSTEXPR = 0x8,
/* When parsing a decl-specifier-seq, only allow mutable, constexpr or
   for C++20 consteval.  */
CP_PARSER_FLAGS_ONLY_MUTABLE_OR_CONSTEXPR = 0x10,
/* When parsing a decl-specifier-seq, allow missing typename.  */
CP_PARSER_FLAGS_TYPENAME_OPTIONAL = 0x20,
/* When parsing of the noexcept-specifier should be delayed.  */
CP_PARSER_FLAGS_DELAY_NOEXCEPT = 0x40,
/* When parsing a consteval declarator.  */
CP_PARSER_FLAGS_CONSTEVAL = 0x80
1876};

1878/* This type is used for parameters and variables which hold
 combinations of the above flags.  */
1880typedef int cp_parser_flags;

1882/* The different kinds of declarators we want to parse.  */

1884enum cp_parser_declarator_kind
1885{
/* We want an abstract declarator.  */
CP_PARSER_DECLARATOR_ABSTRACT,
/* We want a named declarator.  */
CP_PARSER_DECLARATOR_NAMED,
/* We don't mind, but the name must be an unqualified-id.  */
CP_PARSER_DECLARATOR_EITHER
1892};

1894/* The precedence values used to parse binary expressions.  The minimum value
 of PREC must be 1, because zero is reserved to quickly discriminate
 binary operators from other tokens.  */

1898enum cp_parser_prec
1899{
PREC_NOT_OPERATOR,
PREC_LOGICAL_OR_EXPRESSION,
PREC_LOGICAL_AND_EXPRESSION,
PREC_INCLUSIVE_OR_EXPRESSION,
PREC_EXCLUSIVE_OR_EXPRESSION,
PREC_AND_EXPRESSION,
PREC_EQUALITY_EXPRESSION,
PREC_RELATIONAL_EXPRESSION,
PREC_SPACESHIP_EXPRESSION,
PREC_SHIFT_EXPRESSION,
PREC_ADDITIVE_EXPRESSION,
PREC_MULTIPLICATIVE_EXPRESSION,
PREC_PM_EXPRESSION,
NUM_PREC_VALUES = PREC_PM_EXPRESSION
1914};

1916/* A mapping from a token type to a corresponding tree node type, with a
 precedence value.  */

1919struct cp_parser_binary_operations_map_node
1920{
/* The token type.  */
enum cpp_ttype token_type;
/* The corresponding tree code.  */
enum tree_code tree_type;
/* The precedence of this operator.  */
enum cp_parser_prec prec;
1927};

1929struct cp_parser_expression_stack_entry
1930{
/* Left hand side of the binary operation we are currently
   parsing.  */
cp_expr lhs;
/* Original tree code for left hand side, if it was a binary
   expression itself (used for -Wparentheses).  */
enum tree_code lhs_type;
/* Tree code for the binary operation we are parsing.  */
enum tree_code tree_type;
/* Precedence of the binary operation we are parsing.  */
enum cp_parser_prec prec;
/* Location of the binary operation we are parsing.  */
location_t loc;
1943};

1945/* The stack for storing partial expressions.  We only need NUM_PREC_VALUES
 entries because precedence levels on the stack are monotonically
 increasing.  */
1948typedef struct cp_parser_expression_stack_entry
cp_parser_expression_stack[NUM_PREC_VALUES];

1951/* Prototypes.  */

1953/* Constructors and destructors.  */

1955static cp_parser_context *cp_parser_context_new
(cp_parser_context *);

1958/* Class variables.  */

1960static GTY((deletable)) cp_parser_context* cp_parser_context_free_list;

1962/* The operator-precedence table used by cp_parser_binary_expression.
 Transformed into an associative array (binops_by_token) by
 cp_parser_new.  */

1966static const cp_parser_binary_operations_map_node binops[] = {
{ CPP_DEREF_STAR, MEMBER_REF, PREC_PM_EXPRESSION },
{ CPP_DOT_STAR, DOTSTAR_EXPR, PREC_PM_EXPRESSION },

{ CPP_MULT, MULT_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
{ CPP_DIV, TRUNC_DIV_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },
{ CPP_MOD, TRUNC_MOD_EXPR, PREC_MULTIPLICATIVE_EXPRESSION },

{ CPP_PLUS, PLUS_EXPR, PREC_ADDITIVE_EXPRESSION },
{ CPP_MINUS, MINUS_EXPR, PREC_ADDITIVE_EXPRESSION },

{ CPP_LSHIFT, LSHIFT_EXPR, PREC_SHIFT_EXPRESSION },
{ CPP_RSHIFT, RSHIFT_EXPR, PREC_SHIFT_EXPRESSION },

{ CPP_SPACESHIP, SPACESHIP_EXPR, PREC_SPACESHIP_EXPRESSION },

{ CPP_LESS, LT_EXPR, PREC_RELATIONAL_EXPRESSION },
{ CPP_GREATER, GT_EXPR, PREC_RELATIONAL_EXPRESSION },
{ CPP_LESS_EQ, LE_EXPR, PREC_RELATIONAL_EXPRESSION },
{ CPP_GREATER_EQ, GE_EXPR, PREC_RELATIONAL_EXPRESSION },

{ CPP_EQ_EQ, EQ_EXPR, PREC_EQUALITY_EXPRESSION },
{ CPP_NOT_EQ, NE_EXPR, PREC_EQUALITY_EXPRESSION },

{ CPP_AND, BIT_AND_EXPR, PREC_AND_EXPRESSION },

{ CPP_XOR, BIT_XOR_EXPR, PREC_EXCLUSIVE_OR_EXPRESSION },

{ CPP_OR, BIT_IOR_EXPR, PREC_INCLUSIVE_OR_EXPRESSION },

{ CPP_AND_AND, TRUTH_ANDIF_EXPR, PREC_LOGICAL_AND_EXPRESSION },

{ CPP_OR_OR, TRUTH_ORIF_EXPR, PREC_LOGICAL_OR_EXPRESSION }
1999};

2001/* The same as binops, but initialized by cp_parser_new so that
 binops_by_token[N].token_type == N.  Used in cp_parser_binary_expression
 for speed.  */
2004static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES((int) (((enum cpp_ttype) (((enum cpp_ttype) (((enum cpp_ttype
) (((enum cpp_ttype) (CPP_KEYWORD + 1)) + 1)) + 1)) + 1)) + 1
))];

2006/* Constructors and destructors.  */

2008/* Construct a new context.  The context below this one on the stack
 is given by NEXT.  */

2011static cp_parser_context *
2012cp_parser_context_new (cp_parser_context* next)
2013{
cp_parser_context *context;

/* Allocate the storage.  */
if (cp_parser_context_free_list != NULL__null)
  {
    /* Pull the first entry from the free list.  */
    context = cp_parser_context_free_list;
    cp_parser_context_free_list = context->next;
    memset (context, 0, sizeof (*context));
  }
else
  context = ggc_cleared_alloc<cp_parser_context> ();

/* No errors have occurred yet in this context.  */
context->status = CP_PARSER_STATUS_KIND_NO_ERROR;
/* If this is not the bottommost context, copy information that we
   need from the previous context.  */
if (next)
  {
    /* If, in the NEXT context, we are parsing an `x->' or `x.'
expression, then we are parsing one in this context, too.  */
    context->object_type = next->object_type;
    /* Thread the stack.  */
    context->next = next;
  }

return context;
2041}

2043/* Managing the unparsed function queues.  */

2045#define unparsed_funs_with_default_argsparser->unparsed_queues->last ().funs_with_default_args \
parser->unparsed_queues->last ().funs_with_default_args
2047#define unparsed_funs_with_definitionsparser->unparsed_queues->last ().funs_with_definitions \
parser->unparsed_queues->last ().funs_with_definitions
2049#define unparsed_nsdmisparser->unparsed_queues->last ().nsdmis \
parser->unparsed_queues->last ().nsdmis
2051#define unparsed_noexceptsparser->unparsed_queues->last ().noexcepts \
parser->unparsed_queues->last ().noexcepts

2054static void
2055push_unparsed_function_queues (cp_parser *parser)
2056{
cp_unparsed_functions_entry e = { NULL__null, make_tree_vector (), NULL__null, NULL__null };
vec_safe_push (parser->unparsed_queues, e);
2059}

2061static void
2062pop_unparsed_function_queues (cp_parser *parser)
2063{
release_tree_vector (unparsed_funs_with_definitionsparser->unparsed_queues->last ().funs_with_definitions);
parser->unparsed_queues->pop ();
2066}

2068/* Prototypes.  */

2070/* Constructors and destructors.  */

2072static cp_parser *cp_parser_new
(cp_lexer *);

2075/* Routines to parse various constructs.

 Those that return `tree' will return the error_mark_node (rather
 than NULL_TREE) if a parse error occurs, unless otherwise noted.
 Sometimes, they will return an ordinary node if error-recovery was
 attempted, even though a parse error occurred.  So, to check
 whether or not a parse error occurred, you should always use
 cp_parser_error_occurred.  If the construct is optional (indicated
 either by an `_opt' in the name of the function that does the
 parsing or via a FLAGS parameter), then NULL_TREE is returned if
 the construct is not present.  */

2087/* Lexical conventions [gram.lex]  */

2089static cp_expr cp_parser_identifier
(cp_parser *);
2091static cp_expr cp_parser_string_literal
(cp_parser *, bool, bool, bool);
2093static cp_expr cp_parser_userdef_char_literal
(cp_parser *);
2095static tree cp_parser_userdef_string_literal
(tree);
2097static cp_expr cp_parser_userdef_numeric_literal
(cp_parser *);

2100/* Basic concepts [gram.basic]  */

2102static void cp_parser_translation_unit (cp_parser *);

2104/* Expressions [gram.expr]  */

2106static cp_expr cp_parser_primary_expression
(cp_parser *, bool, bool, bool, cp_id_kind *);
2108static cp_expr cp_parser_id_expression
(cp_parser *, bool, bool, bool *, bool, bool);
2110static cp_expr cp_parser_unqualified_id
(cp_parser *, bool, bool, bool, bool);
2112static tree cp_parser_nested_name_specifier_opt
(cp_parser *, bool, bool, bool, bool, bool = false);
2114static tree cp_parser_nested_name_specifier
(cp_parser *, bool, bool, bool, bool);
2116static tree cp_parser_qualifying_entity
(cp_parser *, bool, bool, bool, bool, bool);
2118static cp_expr cp_parser_postfix_expression
(cp_parser *, bool, bool, bool, bool, cp_id_kind *);
2120static tree cp_parser_postfix_open_square_expression
(cp_parser *, tree, bool, bool);
2122static tree cp_parser_postfix_dot_deref_expression
(cp_parser *, enum cpp_ttype, cp_expr, bool, cp_id_kind *, location_t);
2124static vec<tree, va_gc> *cp_parser_parenthesized_expression_list
(cp_parser *, int, bool, bool, bool *, location_t * = NULL__null,
 bool = false);
2127/* Values for the second parameter of cp_parser_parenthesized_expression_list.  */
2128enum { non_attr = 0, normal_attr = 1, id_attr = 2 };
2129static void cp_parser_pseudo_destructor_name
(cp_parser *, tree, tree *, tree *);
2131static cp_expr cp_parser_unary_expression
(cp_parser *, cp_id_kind * = NULL__null, bool = false, bool = false, bool = false);
2133static enum tree_code cp_parser_unary_operator
(cp_token *);
2135static tree cp_parser_has_attribute_expression
(cp_parser *);
2137static tree cp_parser_new_expression
(cp_parser *);
2139static vec<tree, va_gc> *cp_parser_new_placement
(cp_parser *);
2141static tree cp_parser_new_type_id
(cp_parser *, tree *);
2143static cp_declarator *cp_parser_new_declarator_opt
(cp_parser *);
2145static cp_declarator *cp_parser_direct_new_declarator
(cp_parser *);
2147static vec<tree, va_gc> *cp_parser_new_initializer
(cp_parser *);
2149static tree cp_parser_delete_expression
(cp_parser *);
2151static cp_expr cp_parser_cast_expression
(cp_parser *, bool, bool, bool, cp_id_kind *);
2153static cp_expr cp_parser_binary_expression
(cp_parser *, bool, bool, enum cp_parser_prec, cp_id_kind *);
2155static tree cp_parser_question_colon_clause
(cp_parser *, cp_expr);
2157static cp_expr cp_parser_assignment_expression
(cp_parser *, cp_id_kind * = NULL__null, bool = false, bool = false);
2159static enum tree_code cp_parser_assignment_operator_opt
(cp_parser *);
2161static cp_expr cp_parser_expression
(cp_parser *, cp_id_kind * = NULL__null, bool = false, bool = false, bool = false);
2163static cp_expr cp_parser_constant_expression
(cp_parser *, bool = false, bool * = NULL__null, bool = false);
2165static cp_expr cp_parser_builtin_offsetof
(cp_parser *);
2167static cp_expr cp_parser_lambda_expression
(cp_parser *);
2169static void cp_parser_lambda_introducer
(cp_parser *, tree);
2171static bool cp_parser_lambda_declarator_opt
(cp_parser *, tree);
2173static void cp_parser_lambda_body
(cp_parser *, tree);

2176/* Statements [gram.stmt.stmt]  */

2178static void cp_parser_statement
(cp_parser *, tree, bool, bool *, vec<tree> * = NULL__null, location_t * = NULL__null);
2180static void cp_parser_label_for_labeled_statement
2181(cp_parser *, tree);
2182static tree cp_parser_expression_statement
(cp_parser *, tree);
2184static tree cp_parser_compound_statement
(cp_parser *, tree, int, bool);
2186static void cp_parser_statement_seq_opt
(cp_parser *, tree);
2188static tree cp_parser_selection_statement
(cp_parser *, bool *, vec<tree> *);
2190static tree cp_parser_condition
(cp_parser *);
2192static tree cp_parser_iteration_statement
(cp_parser *, bool *, bool, unsigned short);
2194static bool cp_parser_init_statement
(cp_parser *, tree *decl);
2196static tree cp_parser_for
(cp_parser *, bool, unsigned short);
2198static tree cp_parser_c_for
(cp_parser *, tree, tree, bool, unsigned short);
2200static tree cp_parser_range_for
(cp_parser *, tree, tree, tree, bool, unsigned short, bool);
2202static void do_range_for_auto_deduction
(tree, tree);
2204static tree cp_parser_perform_range_for_lookup
(tree, tree *, tree *);
2206static tree cp_parser_range_for_member_function
(tree, tree);
2208static tree cp_parser_jump_statement
(cp_parser *);
2210static void cp_parser_declaration_statement
(cp_parser *);

2213static tree cp_parser_implicitly_scoped_statement
(cp_parser *, bool *, const token_indent_info &, vec<tree> * = NULL__null);
2215static void cp_parser_already_scoped_statement
(cp_parser *, bool *, const token_indent_info &);

2218/* State of module-declaration parsing.  */
2219enum module_parse
2220{
MP_NOT_MODULE,	/* Not a module.  */

_MP_UNUSED,

MP_FIRST,	/* First declaration of TU.  */
MP_GLOBAL,	/* Global Module Fragment.  */

MP_PURVIEW_IMPORTS,   /* Imports of a module.  */
MP_PURVIEW,	/* Purview of a named module.  */

MP_PRIVATE_IMPORTS, /* Imports of a Private Module Fragment.  */
MP_PRIVATE,   /* Private Module Fragment.  */
2233};

2235static module_parse cp_parser_module_declaration
(cp_parser *parser, module_parse, bool exporting);
2237static void cp_parser_import_declaration
(cp_parser *parser, module_parse, bool exporting);

2240/* Declarations [gram.dcl.dcl] */

2242static void cp_parser_declaration_seq_opt
(cp_parser *);
2244static void cp_parser_declaration
(cp_parser *, tree);
2246static void cp_parser_toplevel_declaration
(cp_parser *);
2248static void cp_parser_block_declaration
(cp_parser *, bool);
2250static void cp_parser_simple_declaration
(cp_parser *, bool, tree *);
2252static void cp_parser_decl_specifier_seq
(cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *);
2254static tree cp_parser_storage_class_specifier_opt
(cp_parser *);
2256static tree cp_parser_function_specifier_opt
(cp_parser *, cp_decl_specifier_seq *);
2258static tree cp_parser_type_specifier
(cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool,
 int *, bool *);
2261static tree cp_parser_simple_type_specifier
(cp_parser *, cp_decl_specifier_seq *, cp_parser_flags);
2263static tree cp_parser_placeholder_type_specifier
(cp_parser *, location_t, tree, bool);
2265static tree cp_parser_type_name
(cp_parser *, bool);
2267static tree cp_parser_nonclass_name
(cp_parser* parser);
2269static tree cp_parser_elaborated_type_specifier
(cp_parser *, bool, bool);
2271static tree cp_parser_enum_specifier
(cp_parser *);
2273static void cp_parser_enumerator_list
(cp_parser *, tree);
2275static void cp_parser_enumerator_definition
(cp_parser *, tree);
2277static tree cp_parser_namespace_name
(cp_parser *);
2279static void cp_parser_namespace_definition
(cp_parser *);
2281static void cp_parser_namespace_body
(cp_parser *);
2283static tree cp_parser_qualified_namespace_specifier
(cp_parser *);
2285static void cp_parser_namespace_alias_definition
(cp_parser *);
2287static bool cp_parser_using_declaration
(cp_parser *, bool);
2289static void cp_parser_using_directive
(cp_parser *);
2291static void cp_parser_using_enum
(cp_parser *);
2293static tree cp_parser_alias_declaration
(cp_parser *);
2295static void cp_parser_asm_definition
(cp_parser *);
2297static void cp_parser_linkage_specification
(cp_parser *, tree);
2299static void cp_parser_static_assert
(cp_parser *, bool);
2301static tree cp_parser_decltype
(cp_parser *);
2303static tree cp_parser_decomposition_declaration
(cp_parser *, cp_decl_specifier_seq *, tree *, location_t *);

2306/* Declarators [gram.dcl.decl] */

2308static tree cp_parser_init_declarator
(cp_parser *, cp_parser_flags, cp_decl_specifier_seq *,
 vec<deferred_access_check, va_gc> *, bool, bool, int, bool *, tree *,
 location_t *, tree *);
2312static cp_declarator *cp_parser_declarator
(cp_parser *, cp_parser_declarator_kind, cp_parser_flags, int *, bool *,
 bool, bool, bool);
2315static cp_declarator *cp_parser_direct_declarator
(cp_parser *, cp_parser_declarator_kind, cp_parser_flags, int *, bool, bool,
 bool);
2318static enum tree_code cp_parser_ptr_operator
(cp_parser *, tree *, cp_cv_quals *, tree *);
2320static cp_cv_quals cp_parser_cv_qualifier_seq_opt
(cp_parser *);
2322static cp_virt_specifiers cp_parser_virt_specifier_seq_opt
(cp_parser *);
2324static cp_ref_qualifier cp_parser_ref_qualifier_opt
(cp_parser *);
2326static tree cp_parser_tx_qualifier_opt
(cp_parser *);
2328static tree cp_parser_late_return_type_opt
(cp_parser *, cp_declarator *, tree &);
2330static tree cp_parser_declarator_id
(cp_parser *, bool);
2332static tree cp_parser_type_id
(cp_parser *, cp_parser_flags = CP_PARSER_FLAGS_NONE, location_t * = NULL__null);
2334static tree cp_parser_template_type_arg
(cp_parser *);
2336static tree cp_parser_trailing_type_id (cp_parser *);
2337static tree cp_parser_type_id_1
(cp_parser *, cp_parser_flags, bool, bool, location_t *);
2339static void cp_parser_type_specifier_seq
(cp_parser *, cp_parser_flags, bool, bool, cp_decl_specifier_seq *);
2341static tree cp_parser_parameter_declaration_clause
(cp_parser *, cp_parser_flags);
2343static tree cp_parser_parameter_declaration_list
(cp_parser *, cp_parser_flags);
2345static cp_parameter_declarator *cp_parser_parameter_declaration
(cp_parser *, cp_parser_flags, bool, bool *);
2347static tree cp_parser_default_argument
(cp_parser *, bool);
2349static void cp_parser_function_body
(cp_parser *, bool);
2351static tree cp_parser_initializer
(cp_parser *, bool *, bool *, bool = false);
2353static cp_expr cp_parser_initializer_clause
(cp_parser *, bool *);
2355static cp_expr cp_parser_braced_list
(cp_parser*, bool*);
2357static vec<constructor_elt, va_gc> *cp_parser_initializer_list
(cp_parser *, bool *, bool *);

2360static void cp_parser_ctor_initializer_opt_and_function_body
(cp_parser *, bool);

2363static tree cp_parser_late_parsing_omp_declare_simd
(cp_parser *, tree);

2366static tree cp_parser_late_parsing_oacc_routine
(cp_parser *, tree);

2369static tree synthesize_implicit_template_parm
(cp_parser *, tree);
2371static tree finish_fully_implicit_template
(cp_parser *, tree);
2373static void abort_fully_implicit_template
(cp_parser *);

2376/* Classes [gram.class] */

2378static tree cp_parser_class_name
(cp_parser *, bool, bool, enum tag_types, bool, bool, bool, bool = false);
2380static tree cp_parser_class_specifier
(cp_parser *);
2382static tree cp_parser_class_head
(cp_parser *, bool *);
2384static enum tag_types cp_parser_class_key
(cp_parser *);
2386static void cp_parser_type_parameter_key
(cp_parser* parser);
2388static void cp_parser_member_specification_opt
(cp_parser *);
2390static void cp_parser_member_declaration
(cp_parser *);
2392static tree cp_parser_pure_specifier
(cp_parser *);
2394static tree cp_parser_constant_initializer
(cp_parser *);

2397/* Derived classes [gram.class.derived] */

2399static tree cp_parser_base_clause
(cp_parser *);
2401static tree cp_parser_base_specifier
(cp_parser *);

2404/* Special member functions [gram.special] */

2406static tree cp_parser_conversion_function_id
(cp_parser *);
2408static tree cp_parser_conversion_type_id
(cp_parser *);
2410static cp_declarator *cp_parser_conversion_declarator_opt
(cp_parser *);
2412static void cp_parser_ctor_initializer_opt
(cp_parser *);
2414static void cp_parser_mem_initializer_list
(cp_parser *);
2416static tree cp_parser_mem_initializer
(cp_parser *);
2418static tree cp_parser_mem_initializer_id
(cp_parser *);

2421/* Overloading [gram.over] */

2423static cp_expr cp_parser_operator_function_id
(cp_parser *);
2425static cp_expr cp_parser_operator
(cp_parser *, location_t);

2428/* Templates [gram.temp] */

2430static void cp_parser_template_declaration
(cp_parser *, bool);
2432static tree cp_parser_template_parameter_list
(cp_parser *);
2434static tree cp_parser_template_parameter
(cp_parser *, bool *, bool *);
2436static tree cp_parser_type_parameter
(cp_parser *, bool *);
2438static tree cp_parser_template_id
(cp_parser *, bool, bool, enum tag_types, bool);
2440static tree cp_parser_template_id_expr
(cp_parser *, bool, bool, bool);
2442static tree cp_parser_template_name
(cp_parser *, bool, bool, bool, enum tag_types, bool *);
2444static tree cp_parser_template_argument_list
(cp_parser *);
2446static tree cp_parser_template_argument
(cp_parser *);
2448static void cp_parser_explicit_instantiation
(cp_parser *);
2450static void cp_parser_explicit_specialization
(cp_parser *);

2453/* Exception handling [gram.except] */

2455static tree cp_parser_try_block
(cp_parser *);
2457static void cp_parser_function_try_block
(cp_parser *);
2459static void cp_parser_handler_seq
(cp_parser *);
2461static void cp_parser_handler
(cp_parser *);
2463static tree cp_parser_exception_declaration
(cp_parser *);
2465static tree cp_parser_throw_expression
(cp_parser *);
2467static tree cp_parser_exception_specification_opt
(cp_parser *, cp_parser_flags);
2469static tree cp_parser_type_id_list
(cp_parser *);
2471static tree cp_parser_noexcept_specification_opt
(cp_parser *, cp_parser_flags, bool, bool *, bool);

2474/* GNU Extensions */

2476static tree cp_parser_asm_specification_opt
(cp_parser *);
2478static tree cp_parser_asm_operand_list
(cp_parser *);
2480static tree cp_parser_asm_clobber_list
(cp_parser *);
2482static tree cp_parser_asm_label_list
(cp_parser *);
2484static bool cp_next_tokens_can_be_attribute_p
(cp_parser *);
2486static bool cp_next_tokens_can_be_gnu_attribute_p
(cp_parser *);
2488static bool cp_next_tokens_can_be_std_attribute_p
(cp_parser *);
2490static bool cp_nth_tokens_can_be_std_attribute_p
(cp_parser *, size_t);
2492static bool cp_nth_tokens_can_be_gnu_attribute_p
(cp_parser *, size_t);
2494static bool cp_nth_tokens_can_be_attribute_p
(cp_parser *, size_t);
2496static tree cp_parser_attributes_opt
(cp_parser *);
2498static tree cp_parser_gnu_attributes_opt
(cp_parser *);
2500static tree cp_parser_gnu_attribute_list
(cp_parser *, bool = false);
2502static tree cp_parser_std_attribute
(cp_parser *, tree);
2504static tree cp_parser_std_attribute_spec
(cp_parser *);
2506static tree cp_parser_std_attribute_spec_seq
(cp_parser *);
2508static size_t cp_parser_skip_attributes_opt
(cp_parser *, size_t);
2510static bool cp_parser_extension_opt
(cp_parser *, int *);
2512static void cp_parser_label_declaration
(cp_parser *);

2515/* Concept Extensions */

2517static tree cp_parser_concept_definition
(cp_parser *);
2519static tree cp_parser_constraint_expression
(cp_parser *);
2521static tree cp_parser_requires_clause_opt
(cp_parser *, bool);
2523static tree cp_parser_requires_expression
(cp_parser *);
2525static tree cp_parser_requirement_parameter_list
(cp_parser *);
2527static tree cp_parser_requirement_body
(cp_parser *);
2529static tree cp_parser_requirement_seq
(cp_parser *);
2531static tree cp_parser_requirement
(cp_parser *);
2533static tree cp_parser_simple_requirement
(cp_parser *);
2535static tree cp_parser_compound_requirement
(cp_parser *);
2537static tree cp_parser_type_requirement
(cp_parser *);
2539static tree cp_parser_nested_requirement
(cp_parser *);

2542/* Transactional Memory Extensions */

2544static tree cp_parser_transaction
(cp_parser *, cp_token *);
2546static tree cp_parser_transaction_expression
(cp_parser *, enum rid);
2548static void cp_parser_function_transaction
(cp_parser *, enum rid);
2550static tree cp_parser_transaction_cancel
(cp_parser *);

2553/* Coroutine extensions.  */

2555static tree cp_parser_yield_expression
(cp_parser *);


2559enum pragma_context {
pragma_external,
pragma_member,
pragma_objc_icode,
pragma_stmt,
pragma_compound
2565};
2566static bool cp_parser_pragma
(cp_parser *, enum pragma_context, bool *);

2569/* Objective-C++ Productions */

2571static tree cp_parser_objc_message_receiver
(cp_parser *);
2573static tree cp_parser_objc_message_args
(cp_parser *);
2575static tree cp_parser_objc_message_expression
(cp_parser *);
2577static cp_expr cp_parser_objc_encode_expression
(cp_parser *);
2579static tree cp_parser_objc_defs_expression
(cp_parser *);
2581static tree cp_parser_objc_protocol_expression
(cp_parser *);
2583static tree cp_parser_objc_selector_expression
(cp_parser *);
2585static cp_expr cp_parser_objc_expression
(cp_parser *);
2587static bool cp_parser_objc_selector_p
(enum cpp_ttype);
2589static tree cp_parser_objc_selector
(cp_parser *);
2591static tree cp_parser_objc_protocol_refs_opt
(cp_parser *);
2593static void cp_parser_objc_declaration
(cp_parser *, tree);
2595static tree cp_parser_objc_statement
(cp_parser *);
2597static bool cp_parser_objc_valid_prefix_attributes
(cp_parser *, tree *);
2599static void cp_parser_objc_at_property_declaration
(cp_parser *) ;
2601static void cp_parser_objc_at_synthesize_declaration
(cp_parser *) ;
2603static void cp_parser_objc_at_dynamic_declaration
(cp_parser *) ;
2605static tree cp_parser_objc_struct_declaration
(cp_parser *) ;

2608/* Utility Routines */

2610static cp_expr cp_parser_lookup_name
(cp_parser *, tree, enum tag_types, bool, bool, bool, tree *, location_t);
2612static tree cp_parser_lookup_name_simple
(cp_parser *, tree, location_t);
2614static tree cp_parser_maybe_treat_template_as_class
(tree, bool);
2616static bool cp_parser_check_declarator_template_parameters
(cp_parser *, cp_declarator *, location_t);
2618static bool cp_parser_check_template_parameters
(cp_parser *, unsigned, bool, location_t, cp_declarator *);
2620static cp_expr cp_parser_simple_cast_expression
(cp_parser *);
2622static tree cp_parser_global_scope_opt
(cp_parser *, bool);
2624static bool cp_parser_constructor_declarator_p
(cp_parser *, cp_parser_flags, bool);
2626static tree cp_parser_function_definition_from_specifiers_and_declarator
(cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *);
2628static tree cp_parser_function_definition_after_declarator
(cp_parser *, bool);
2630static bool cp_parser_template_declaration_after_export
(cp_parser *, bool);
2632static void cp_parser_perform_template_parameter_access_checks
(vec<deferred_access_check, va_gc> *);
2634static tree cp_parser_single_declaration
(cp_parser *, vec<deferred_access_check, va_gc> *, bool, bool, bool *);
2636static cp_expr cp_parser_functional_cast
(cp_parser *, tree);
2638static tree cp_parser_save_member_function_body
(cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree);
2640static tree cp_parser_save_nsdmi
(cp_parser *);
2642static tree cp_parser_enclosed_template_argument_list
(cp_parser *);
2644static void cp_parser_save_default_args
(cp_parser *, tree);
2646static void cp_parser_late_parsing_for_member
(cp_parser *, tree);
2648static tree cp_parser_late_parse_one_default_arg
(cp_parser *, tree, tree, tree);
2650static void cp_parser_late_parsing_nsdmi
(cp_parser *, tree);
2652static void cp_parser_late_parsing_default_args
(cp_parser *, tree);
2654static tree cp_parser_sizeof_operand
(cp_parser *, enum rid);
2656static cp_expr cp_parser_trait_expr
(cp_parser *, enum rid);
2658static bool cp_parser_declares_only_class_p
(cp_parser *);
2660static void cp_parser_set_storage_class
(cp_parser *, cp_decl_specifier_seq *, enum rid, cp_token *);
2662static void cp_parser_set_decl_spec_type
(cp_decl_specifier_seq *, tree, cp_token *, bool);
2664static void set_and_check_decl_spec_loc
(cp_decl_specifier_seq *decl_specs,
 cp_decl_spec ds, cp_token *);
2667static bool cp_parser_friend_p
(const cp_decl_specifier_seq *);
2669static void cp_parser_required_error
(cp_parser *, required_token, bool, location_t);
2671static cp_token *cp_parser_require
(cp_parser *, enum cpp_ttype, required_token, location_t = UNKNOWN_LOCATION((location_t) 0));
2673static cp_token *cp_parser_require_keyword
(cp_parser *, enum rid, required_token);
2675static bool cp_parser_token_starts_function_definition_p
(cp_token *);
2677static bool cp_parser_next_token_starts_class_definition_p
(cp_parser *);
2679static bool cp_parser_next_token_ends_template_argument_p
(cp_parser *);
2681static bool cp_parser_nth_token_starts_template_argument_list_p
(cp_parser *, size_t);
2683static enum tag_types cp_parser_token_is_class_key
(cp_token *);
2685static enum tag_types cp_parser_token_is_type_parameter_key
(cp_token *);
2687static void cp_parser_maybe_warn_enum_key (cp_parser *, location_t, tree, rid);
2688static void cp_parser_check_class_key
2689(cp_parser *, location_t, enum tag_types, tree type, bool, bool);
2690static void cp_parser_check_access_in_redeclaration
(tree type, location_t location);
2692static bool cp_parser_optional_template_keyword
(cp_parser *);
2694static void cp_parser_pre_parsed_nested_name_specifier
(cp_parser *);
2696static bool cp_parser_cache_group
(cp_parser *, enum cpp_ttype, unsigned);
2698static tree cp_parser_cache_defarg
(cp_parser *parser, bool nsdmi);
2700static void cp_parser_parse_tentatively
(cp_parser *);
2702static void cp_parser_commit_to_tentative_parse
(cp_parser *);
2704static void cp_parser_commit_to_topmost_tentative_parse
(cp_parser *);
2706static void cp_parser_abort_tentative_parse
(cp_parser *);
2708static bool cp_parser_parse_definitely
(cp_parser *);
2710static inline bool cp_parser_parsing_tentatively
(cp_parser *);
2712static bool cp_parser_uncommitted_to_tentative_parse_p
(cp_parser *);
2714static void cp_parser_error
(cp_parser *, const char *);
2716static void cp_parser_name_lookup_error
(cp_parser *, tree, tree, name_lookup_error, location_t);
2718static bool cp_parser_simulate_error
(cp_parser *);
2720static bool cp_parser_check_type_definition
(cp_parser *);
2722static void cp_parser_check_for_definition_in_return_type
(cp_declarator *, tree, location_t type_location);
2724static void cp_parser_check_for_invalid_template_id
(cp_parser *, tree, enum tag_types, location_t location);
2726static bool cp_parser_non_integral_constant_expression
(cp_parser *, non_integral_constant);
2728static void cp_parser_diagnose_invalid_type_name
(cp_parser *, tree, location_t);
2730static bool cp_parser_parse_and_diagnose_invalid_type_name
(cp_parser *);
2732static int cp_parser_skip_to_closing_parenthesis
(cp_parser *, bool, bool, bool);
2734static void cp_parser_skip_to_end_of_statement
(cp_parser *);
2736static void cp_parser_consume_semicolon_at_end_of_statement
(cp_parser *);
2738static void cp_parser_skip_to_end_of_block_or_statement
(cp_parser *);
2740static bool cp_parser_skip_to_closing_brace
(cp_parser *);
2742static void cp_parser_skip_to_end_of_template_parameter_list
(cp_parser *);
2744static void cp_parser_skip_to_pragma_eol
(cp_parser*, cp_token *);
2746static bool cp_parser_error_occurred
(cp_parser *);
2748static bool cp_parser_allow_gnu_extensions_p
(cp_parser *);
2750static bool cp_parser_is_pure_string_literal
(cp_token *);
2752static bool cp_parser_is_string_literal
(cp_token *);
2754static bool cp_parser_is_keyword
(cp_token *, enum rid);
2756static tree cp_parser_make_typename_type
(cp_parser *, tree, location_t location);
2758static cp_declarator * cp_parser_make_indirect_declarator
(enum tree_code, tree, cp_cv_quals, cp_declarator *, tree);
2760static bool cp_parser_compound_literal_p
(cp_parser *);
2762static bool cp_parser_array_designator_p
(cp_parser *);
2764static bool cp_parser_init_statement_p
(cp_parser *);
2766static bool cp_parser_skip_to_closing_square_bracket
(cp_parser *);
2768static size_t cp_parser_skip_balanced_tokens (cp_parser *, size_t);

2770// -------------------------------------------------------------------------- //
2771// Unevaluated Operand Guard
2772//
2773// Implementation of an RAII helper for unevaluated operand parsing.
2774cp_unevaluated::cp_unevaluated ()
2775{
++cp_unevaluated_operand;
++c_inhibit_evaluation_warnings;
2778}

2780cp_unevaluated::~cp_unevaluated ()
2781{
--c_inhibit_evaluation_warnings;
--cp_unevaluated_operand;
2784}

2786// -------------------------------------------------------------------------- //
2787// Tentative Parsing

2789/* Returns nonzero if we are parsing tentatively.  */

2791static inline bool
2792cp_parser_parsing_tentatively (cp_parser* parser)
2793{
return parser->context->next != NULL__null;
2795}

2797/* Returns nonzero if TOKEN is a string literal.  */

2799static bool
2800cp_parser_is_pure_string_literal (cp_token* token)
2801{
return (token->type == CPP_STRING ||
 token->type == CPP_STRING16 ||
 token->type == CPP_STRING32 ||
 token->type == CPP_WSTRING ||
 token->type == CPP_UTF8STRING);
2807}

2809/* Returns nonzero if TOKEN is a string literal
 of a user-defined string literal.  */

2812static bool
2813cp_parser_is_string_literal (cp_token* token)
2814{
return (cp_parser_is_pure_string_literal (token) ||
 token->type == CPP_STRING_USERDEF ||
 token->type == CPP_STRING16_USERDEF ||
 token->type == CPP_STRING32_USERDEF ||
 token->type == CPP_WSTRING_USERDEF ||
 token->type == CPP_UTF8STRING_USERDEF);
2821}

2823/* Returns nonzero if TOKEN is the indicated KEYWORD.  */

2825static bool
2826cp_parser_is_keyword (cp_token* token, enum rid keyword)
2827{
return token->keyword == keyword;
2829}

2831/* Return TOKEN's pragma_kind if it is CPP_PRAGMA, otherwise
 PRAGMA_NONE.  */

2834static enum pragma_kind
2835cp_parser_pragma_kind (cp_token *token)
2836{
if (token->type != CPP_PRAGMA)
  return PRAGMA_NONE;
/* We smuggled the cpp_token->u.pragma value in an INTEGER_CST.  */
return (enum pragma_kind) TREE_INT_CST_LOW (token->u.value)((unsigned long) (*tree_int_cst_elt_check ((token->u.value
), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 2840, __FUNCTION__)));
2841}

2843/* Helper function for cp_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 tokens ("<<") and a CPP_LESS token ('<').
 If it returns true, *OUT_LOC is written to with the location/range
 of the marker.  */

2854static bool
2855cp_lexer_peek_conflict_marker (cp_lexer *lexer, enum cpp_ttype tok1_kind,
	       location_t *out_loc)
2857{
cp_token *token2 = cp_lexer_peek_nth_token (lexer, 2);
if (token2->type != tok1_kind)
  return false;
cp_token *token3 = cp_lexer_peek_nth_token (lexer, 3);
if (token3->type != tok1_kind)
  return false;
cp_token *token4 = cp_lexer_peek_nth_token (lexer, 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 = cp_lexer_peek_token (lexer)->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;
2881}

2883/* Get a description of the matching symbol to TOKEN_DESC e.g. "(" for
 RT_CLOSE_PAREN.  */

2886static const char *
2887get_matching_symbol (required_token token_desc)
2888{
switch (token_desc)
  {
  default:
    gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 2892, __FUNCTION__));
    return "";
  case RT_CLOSE_BRACE:
    return "{";
  case RT_CLOSE_PAREN:
    return "(";
  }
2899}

2901/* Attempt to convert TOKEN_DESC from a required_token to an
 enum cpp_ttype, returning CPP_EOF if there is no good conversion.  */

2904static enum cpp_ttype
2905get_required_cpp_ttype (required_token token_desc)
2906{
switch (token_desc)
  {
  case RT_SEMICOLON:
    return CPP_SEMICOLON;
  case RT_OPEN_PAREN:
    return CPP_OPEN_PAREN;
  case RT_CLOSE_BRACE:
    return CPP_CLOSE_BRACE;
  case RT_OPEN_BRACE:
    return CPP_OPEN_BRACE;
  case RT_CLOSE_SQUARE:
    return CPP_CLOSE_SQUARE;
  case RT_OPEN_SQUARE:
    return CPP_OPEN_SQUARE;
  case RT_COMMA:
    return CPP_COMMA;
  case RT_COLON:
    return CPP_COLON;
  case RT_CLOSE_PAREN:
    return CPP_CLOSE_PAREN;

  default:
    /* Use CPP_EOF as a "no completions possible" code.  */
    return CPP_EOF;
  }
2932}


2935/* Subroutine of cp_parser_error and cp_parser_required_error.

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

 This bypasses the check for tentative passing, and potentially
 adds material needed by cp_parser_required_error.

 If MISSING_TOKEN_DESC is not RT_NONE, then potentially add fix-it hints
 suggesting insertion of the missing token.

 Additionally, if MATCHING_LOCATION is not UNKNOWN_LOCATION, then we
 have an unmatched symbol at MATCHING_LOCATION; highlight this secondary
 location.  */

2953static void
2954cp_parser_error_1 (cp_parser* parser, const char* gmsgid,
   required_token missing_token_desc,
   location_t matching_location)
2957{
cp_token *token = cp_lexer_peek_token (parser->lexer);
/* This diagnostic makes more sense if it is tagged to the line
   of the token we just peeked at.  */
cp_lexer_set_source_position_from_token (token);

if (token->type == CPP_PRAGMA)
  {
    error_at (token->location,
"%<#pragma%> is not allowed here");
    cp_parser_skip_to_pragma_eol (parser, token);
    return;
  }

/* 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 (cp_lexer_peek_conflict_marker (parser->lexer, token->type, &loc))
{
 error_at (loc, "version control conflict marker in file");
 expanded_location token_exploc = expand_location (token->location);
 /* Consume tokens until the end of the source line.  */
 for (;;)
   {
     cp_lexer_consume_token (parser->lexer);
     cp_token *next = cp_lexer_peek_token (parser->lexer);
     if (next->type == CPP_EOF)
break;
     if (next->location == UNKNOWN_LOCATION((location_t) 0)
  || loc == UNKNOWN_LOCATION((location_t) 0))
break;

     expanded_location next_exploc = expand_location (next->location);
     if (next_exploc.file != token_exploc.file)
break;
     if (next_exploc.line != token_exploc.line)
break;
   }
 return;
}
  }

auto_diagnostic_group d;
gcc_rich_location richloc (input_location);

bool added_matching_location = false;

if (missing_token_desc != RT_NONE)
  if (cp_token *prev_token = cp_lexer_safe_previous_token (parser->lexer))
    {
/* 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.  */
enum cpp_ttype ttype = get_required_cpp_ttype (missing_token_desc);
location_t prev_token_loc = prev_token->location;
maybe_suggest_missing_token_insertion (&richloc, ttype,
			       prev_token_loc);

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

/* 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. */
name_hint h;
if (token->type == CPP_NAME)
  if (cp_token *prev_token = cp_lexer_safe_previous_token (parser->lexer))
    if (cp_parser_is_string_literal (prev_token))
{
 tree name = token->u.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/cp/parser.c"
, 3037, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
);
 const char *header_hint
   = get_cp_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));
}

/* Actually emit the error.  */
c_parse_error (gmsgid,
 /* Because c_parser_error does not understand
    CPP_KEYWORD, keywords are treated like
    identifiers.  */
 (token->type == CPP_KEYWORD ? CPP_NAME : token->type),
 token->u.value, token->flags, &richloc);

if (missing_token_desc != RT_NONE)
  {
    /* 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 (missing_token_desc));
  }
3063}

3065/* If not parsing tentatively, issue a diagnostic of the form
    FILE:LINE: MESSAGE before TOKEN
 where TOKEN is the next token in the input stream.  MESSAGE
 (specified by the caller) is usually of the form "expected
 OTHER-TOKEN".  */

3071static void
3072cp_parser_error (cp_parser* parser, const char* gmsgid)
3073{
if (!cp_parser_simulate_error (parser))
  cp_parser_error_1 (parser, gmsgid, RT_NONE, UNKNOWN_LOCATION((location_t) 0));
3076}

3078/* Issue an error about name-lookup failing.  NAME is the
 IDENTIFIER_NODE DECL is the result of
 the lookup (as returned from cp_parser_lookup_name).  DESIRED is
 the thing that we hoped to find.  */

3083static void
3084cp_parser_name_lookup_error (cp_parser* parser,
	     tree name,
	     tree decl,
	     name_lookup_error desired,
	     location_t location)
3089{
/* If name lookup completely failed, tell the user that NAME was not
   declared.  */
if (decl == error_mark_nodeglobal_trees[TI_ERROR_MARK])
  {
    if (parser->scope && parser->scope != global_namespacecp_global_trees[CPTI_GLOBAL])
error_at (location, "%<%E::%E%> has not been declared",
  parser->scope, name);
    else if (parser->scope == global_namespacecp_global_trees[CPTI_GLOBAL])
error_at (location, "%<::%E%> has not been declared", name);
    else if (parser->object_scope
      && !CLASS_TYPE_P (parser->object_scope)(((((enum tree_code) (parser->object_scope)->base.code)
) == RECORD_TYPE || (((enum tree_code) (parser->object_scope
)->base.code)) == UNION_TYPE) && ((tree_class_check
 ((parser->object_scope), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3100, __FUNCTION__))->type_common.lang_flag_5)))
error_at (location, "request for member %qE in non-class type %qT",
  name, parser->object_scope);
    else if (parser->object_scope)
error_at (location, "%<%T::%E%> has not been declared",
  parser->object_scope, name);
    else
error_at (location, "%qE has not been declared", name);
  }
else if (parser->scope && parser->scope != global_namespacecp_global_trees[CPTI_GLOBAL])
  {
    switch (desired)
{
 case NLE_TYPE:
   error_at (location, "%<%E::%E%> is not a type",
   			parser->scope, name);
   break;
 case NLE_CXX98:
   error_at (location, "%<%E::%E%> is not a class or namespace",
   			parser->scope, name);
   break;
 case NLE_NOT_CXX98:
   error_at (location,
   	      "%<%E::%E%> is not a class, namespace, or enumeration",
      parser->scope, name);
   break;
 default:
   gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3127, __FUNCTION__));

}
  }
else if (parser->scope == global_namespacecp_global_trees[CPTI_GLOBAL])
  {
    switch (desired)
{
 case NLE_TYPE:
   error_at (location, "%<::%E%> is not a type", name);
   break;
 case NLE_CXX98:
   error_at (location, "%<::%E%> is not a class or namespace", name);
   break;
 case NLE_NOT_CXX98:
   error_at (location,
      "%<::%E%> is not a class, namespace, or enumeration",
      name);
   break;
 default:
   gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3147, __FUNCTION__));
}
  }
else
  {
    switch (desired)
{
 case NLE_TYPE:
   error_at (location, "%qE is not a type", name);
   break;
 case NLE_CXX98:
   error_at (location, "%qE is not a class or namespace", name);
   break;
 case NLE_NOT_CXX98:
   error_at (location,
      "%qE is not a class, namespace, or enumeration", name);
   break;
 default:
   gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3165, __FUNCTION__));
}
  }
3168}

3170/* If we are parsing tentatively, remember that an error has occurred
 during this tentative parse.  Returns true if the error was
 simulated; false if a message should be issued by the caller.  */

3174static bool
3175cp_parser_simulate_error (cp_parser* parser)
3176{
if (cp_parser_uncommitted_to_tentative_parse_p (parser))
  {
    parser->context->status = CP_PARSER_STATUS_KIND_ERROR;
    return true;
  }
return false;
3183}

3185/* This function is called when a type is defined.  If type
 definitions are forbidden at this point, an error message is
 issued.  */

3189static bool
3190cp_parser_check_type_definition (cp_parser* parser)
3191{
/* If types are forbidden here, issue a message.  */
if (parser->type_definition_forbidden_message)
  {
    /* Don't use `%s' to print the string, because quotations (`%<', `%>')
or %qs in the message need to be interpreted.  */
    error (parser->type_definition_forbidden_message,
    parser->type_definition_forbidden_message_arg);
    return false;
  }
return true;
3202}

3204/* This function is called when the DECLARATOR is processed.  The TYPE
 was a type defined in the decl-specifiers.  If it is invalid to
 define a type in the decl-specifiers for DECLARATOR, an error is
 issued. TYPE_LOCATION is the location of TYPE and is used
 for error reporting.  */

3210static void
3211cp_parser_check_for_definition_in_return_type (cp_declarator *declarator,
			       tree type, location_t type_location)
3213{
/* [dcl.fct] forbids type definitions in return types.
   Unfortunately, it's not easy to know whether or not we are
   processing a return type until after the fact.  */
while (declarator
&& (declarator->kind == cdk_pointer
    || declarator->kind == cdk_reference
    || declarator->kind == cdk_ptrmem))
  declarator = declarator->declarator;
if (declarator
    && declarator->kind == cdk_function)
  {
    error_at (type_location,
"new types may not be defined in a return type");
    inform (type_location,
     "(perhaps a semicolon is missing after the definition of %qT)",
     type);
  }
3231}

3233/* A type-specifier (TYPE) has been parsed which cannot be followed by
 "<" in any valid C++ program.  If the next token is indeed "<",
 issue a message warning the user about what appears to be an
 invalid attempt to form a template-id. LOCATION is the location
 of the type-specifier (TYPE) */

3239static void
3240cp_parser_check_for_invalid_template_id (cp_parser* parser,
			 tree type,
			 enum tag_types tag_type,
			 location_t location)
3244{
cp_token_position start = 0;

if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
  {
    if (TREE_CODE (type)((enum tree_code) (type)->base.code) == TYPE_DECL)
type = TREE_TYPE (type)((contains_struct_check ((type), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3250, __FUNCTION__))->typed.type);
    if (TYPE_P (type)(tree_code_type[(int) (((enum tree_code) (type)->base.code
))] == tcc_type) && !template_placeholder_p (type))
error_at (location, "%qT is not a template", type);
    else if (identifier_p (type))
{
 if (tag_type != none_type)
   error_at (location, "%qE is not a class template", type);
 else
   error_at (location, "%qE is not a template", type);
}
    else
error_at (location, "invalid template-id");
    /* Remember the location of the invalid "<".  */
    if (cp_parser_uncommitted_to_tentative_parse_p (parser))
start = cp_lexer_token_position (parser->lexer, true);
    /* Consume the "<".  */
    cp_lexer_consume_token (parser->lexer);
    /* Parse the template arguments.  */
    cp_parser_enclosed_template_argument_list (parser);
    /* Permanently remove the invalid template arguments so that
this error message is not issued again.  */
    if (start)
cp_lexer_purge_tokens_after (parser->lexer, start);
  }
3274}

3276/* If parsing an integral constant-expression, issue an error message
 about the fact that THING appeared and return true.  Otherwise,
 return false.  In either case, set
 PARSER->NON_INTEGRAL_CONSTANT_EXPRESSION_P.  */

3281static bool
3282cp_parser_non_integral_constant_expression (cp_parser  *parser,
			    non_integral_constant thing)
3284{
parser->non_integral_constant_expression_p = true;
if (parser->integral_constant_expression_p)
  {
    if (!parser->allow_non_integral_constant_expression_p)
{
 const char *msg = NULL__null;
 switch (thing)
   {
	      case NIC_FLOAT:
pedwarn (input_location, OPT_Wpedantic,
	 "ISO C++ forbids using a floating-point literal "
	 "in a constant-expression");
return true;
     case NIC_CAST:
error ("a cast to a type other than an integral or "
       "enumeration type cannot appear in a "
       "constant-expression");
return true;
     case NIC_TYPEID:
error ("%<typeid%> operator "
       "cannot appear in a constant-expression");
return true;
     case NIC_NCC:
error ("non-constant compound literals "
       "cannot appear in a constant-expression");
return true;
     case NIC_FUNC_CALL:
error ("a function call "
       "cannot appear in a constant-expression");
return true;
     case NIC_INC:
error ("an increment "
       "cannot appear in a constant-expression");
return true;
     case NIC_DEC:
error ("an decrement "
       "cannot appear in a constant-expression");
return true;
     case NIC_ARRAY_REF:
error ("an array reference "
       "cannot appear in a constant-expression");
return true;
     case NIC_ADDR_LABEL:
error ("the address of a label "
       "cannot appear in a constant-expression");
return true;
     case NIC_OVERLOADED:
error ("calls to overloaded operators "
       "cannot appear in a constant-expression");
return true;
     case NIC_ASSIGNMENT:
error ("an assignment cannot appear in a constant-expression");
return true;
     case NIC_COMMA:
error ("a comma operator "
       "cannot appear in a constant-expression");
return true;
     case NIC_CONSTRUCTOR:
error ("a call to a constructor "
       "cannot appear in a constant-expression");
return true;
     case NIC_TRANSACTION:
error ("a transaction expression "
       "cannot appear in a constant-expression");
return true;
     case NIC_THIS:
msg = "this";
break;
     case NIC_FUNC_NAME:
msg = "__FUNCTION__";
break;
	      case NIC_PRETTY_FUNC:
msg = "__PRETTY_FUNCTION__";
break;
     case NIC_C99_FUNC:
msg = "__func__";
break;
     case NIC_VA_ARG:
msg = "va_arg";
break;
     case NIC_ARROW:
msg = "->";
break;
     case NIC_POINT:
msg = ".";
break;
     case NIC_STAR:
msg = "*";
break;
     case NIC_ADDR:
msg = "&";
break;
     case NIC_PREINCREMENT:
msg = "++";
break;
     case NIC_PREDECREMENT:
msg = "--";
break;
     case NIC_NEW:
msg = "new";
break;
     case NIC_DEL:
msg = "delete";
break;
     default:
gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3390, __FUNCTION__));
   }
 if (msg)
   error ("%qs cannot appear in a constant-expression", msg);
 return true;
}
  }
return false;
3398}

3400/* Emit a diagnostic for an invalid type name.  This function commits
 to the current active tentative parse, if any.  (Otherwise, the
 problematic construct might be encountered again later, resulting
 in duplicate error messages.) LOCATION is the location of ID.  */

3405static void
3406cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree id,
		      location_t location)
3408{
tree decl, ambiguous_decls;
cp_parser_commit_to_tentative_parse (parser);
/* Try to lookup the identifier.  */
decl = cp_parser_lookup_name (parser, id, none_type,
		/*is_template=*/false,
		/*is_namespace=*/false,
		/*check_dependency=*/true,
		&ambiguous_decls, location);
if (ambiguous_decls)
  /* If the lookup was ambiguous, an error will already have
     been issued.  */
  return;
/* If the lookup found a template-name, it means that the user forgot
to specify an argument list. Emit a useful error message.  */
if (DECL_TYPE_TEMPLATE_P (decl)(((enum tree_code) (decl)->base.code) == TEMPLATE_DECL &&
 ((struct tree_template_decl *)(const_cast<union tree_node
 *> ((((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3423, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
 *)(const_cast<union tree_node *> ((((tree_check ((decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3423, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == TYPE_DECL))
  {
    auto_diagnostic_group d;
    error_at (location,
"invalid use of template-name %qE without an argument list",
decl);
    if (DECL_CLASS_TEMPLATE_P (decl)((((enum tree_code) (decl)->base.code) == TEMPLATE_DECL &&
 ((struct tree_template_decl *)(const_cast<union tree_node
 *> ((((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3429, __FUNCTION__, (TEMPLATE_DECL))))))))->result != (tree
) __null && ((enum tree_code) (((struct tree_template_decl
 *)(const_cast<union tree_node *> ((((tree_check ((decl
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3429, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == TYPE_DECL) && (((enum tree_code) (((struct
 tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3429, __FUNCTION__, (TEMPLATE_DECL))))))))->result)->
base.code) == TYPE_DECL && ((contains_struct_check ((
((struct tree_template_decl *)(const_cast<union tree_node *
> ((((tree_check ((decl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3429, __FUNCTION__, (TEMPLATE_DECL))))))))->result), (TS_DECL_COMMON
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3429, __FUNCTION__))->decl_common.lang_flag_2))) && cxx_dialect < cxx17)
inform (location, "class template argument deduction is only available "
"with %<-std=c++17%> or %<-std=gnu++17%>");
    inform (DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3432, __FUNCTION__))->decl_minimal.locus), "%qD declared here", decl);
  }
else if (TREE_CODE (id)((enum tree_code) (id)->base.code) == BIT_NOT_EXPR)
  error_at (location, "invalid use of destructor %qD as a type", id);
else if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL)
  /* Something like 'unsigned A a;'  */
  error_at (location, "invalid combination of multiple type-specifiers");
else if (!parser->scope)
  {
    /* Issue an error message.  */
    auto_diagnostic_group d;
    name_hint hint;
    if (TREE_CODE (id)((enum tree_code) (id)->base.code) == IDENTIFIER_NODE)
hint = lookup_name_fuzzy (id, FUZZY_LOOKUP_TYPENAME, location);
    if (const char *suggestion = hint.suggestion ())
{
 gcc_rich_location richloc (location);
 richloc.add_fixit_replace (suggestion);
 error_at (&richloc,
    "%qE does not name a type; did you mean %qs?",
    id, suggestion);
}
    else
error_at (location, "%qE does not name a type", id);
    /* If we're in a template class, it's possible that the user was
referring to a type from a base class.  For example:

  template <typename T> struct A { typedef T X; };
  template <typename T> struct B : public A<T> { X x; };

The user should have said "typename A<T>::X".  */
    if (cxx_dialect < cxx11 && id == ridpointers[(int)RID_CONSTEXPR])
inform (location, "C++11 %<constexpr%> only available with "
"%<-std=c++11%> or %<-std=gnu++11%>");
    else if (cxx_dialect < cxx11 && id == ridpointers[(int)RID_NOEXCEPT])
inform (location, "C++11 %<noexcept%> only available with "
"%<-std=c++11%> or %<-std=gnu++11%>");
    else if (TREE_CODE (id)((enum tree_code) (id)->base.code) == IDENTIFIER_NODE
      && (id_equal (id, "module") || id_equal (id, "import")))
{
 if (!modules_p ())
   inform (location, "%qE only available with %<-fmodules-ts%>", id);
 else
   inform (location, "%qE was not recognized as a module control-line",
    id);
}
    else if (cxx_dialect < cxx11
      && TREE_CODE (id)((enum tree_code) (id)->base.code) == IDENTIFIER_NODE
      && id_equal (id, "thread_local"))
inform (location, "C++11 %<thread_local%> only available with "
"%<-std=c++11%> or %<-std=gnu++11%>");
    else if (cxx_dialect < cxx20 && id == ridpointers[(int)RID_CONSTINIT])
inform (location, "C++20 %<constinit%> only available with "
"%<-std=c++20%> or %<-std=gnu++20%>");
    else if (!flag_conceptsglobal_options.x_flag_concepts && id == ridpointers[(int)RID_CONCEPT])
inform (location, "%<concept%> only available with %<-std=c++20%> or "
"%<-fconcepts%>");
    else if (!flag_conceptsglobal_options.x_flag_concepts && id == ridpointers[(int)RID_REQUIRES])
inform (location, "%<requires%> only available with %<-std=c++20%> or "
"%<-fconcepts%>");
    else if (processing_template_declscope_chain->x_processing_template_decl && current_class_typescope_chain->class_type
      && TYPE_BINFO (current_class_type)((tree_check3 ((scope_chain->class_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3493, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval))
{
 for (tree b = TREE_CHAIN (TYPE_BINFO (current_class_type))((contains_struct_check ((((tree_check3 ((scope_chain->class_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3495, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.maxval)), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3495, __FUNCTION__))->common.chain);
      b; b = TREE_CHAIN (b)((contains_struct_check ((b), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3496, __FUNCTION__))->common.chain))
   {
     tree base_type = BINFO_TYPE (b)((contains_struct_check (((tree_check ((b), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3498, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3498, __FUNCTION__))->typed.type);
     if (CLASS_TYPE_P (base_type)(((((enum tree_code) (base_type)->base.code)) == RECORD_TYPE
 || (((enum tree_code) (base_type)->base.code)) == UNION_TYPE
) && ((tree_class_check ((base_type), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3499, __FUNCTION__))->type_common.lang_flag_5))
  && dependent_type_p (base_type))
{
  /* Go from a particular instantiation of the
     template (which will have an empty TYPE_FIELDs),
     to the main version.  */
  base_type = CLASSTYPE_PRIMARY_TEMPLATE_TYPE (base_type)((((((tree_class_check (((base_type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__))->type_with_lang_specific.lang_specific
))->use_template) && !(((((tree_class_check (((base_type
)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__))->type_with_lang_specific.lang_specific
))->use_template) == 2)) ? ((contains_struct_check ((((struct
 tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((((((contains_struct_check ((((tree_check ((((struct
 tree_template_decl *)(const_cast<union tree_node *> ((
((tree_check ((((struct tree_template_info*)(tree_check (((((
tree_class_check (((tree_check3 (((base_type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__))->type_non_common.lang_1))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__, (TEMPLATE_INFO))))->tmpl), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__, (TEMPLATE_DECL))))))))->arguments), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__, (TREE_LIST)))->list.value)), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__))->typed.type)))), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__, (TEMPLATE_DECL))))))))->result), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3505, __FUNCTION__))->typed.type) : (base_type));
  for (tree field = TYPE_FIELDS (base_type)((tree_check3 ((base_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3506, __FUNCTION__, (RECORD_TYPE), (UNION_TYPE), (QUAL_UNION_TYPE
)))->type_non_common.values);
       field; field = DECL_CHAIN (field)(((contains_struct_check (((contains_struct_check ((field), (
TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3507, __FUNCTION__))), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3507, __FUNCTION__))->common.chain)))
    if (TREE_CODE (field)((enum tree_code) (field)->base.code) == TYPE_DECL
	&& DECL_NAME (field)((contains_struct_check ((field), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3509, __FUNCTION__))->decl_minimal.name) == id)
      {
	inform (location,
		"(perhaps %<typename %T::%E%> was intended)",
		BINFO_TYPE (b)((contains_struct_check (((tree_check ((b), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3513, __FUNCTION__, (TREE_BINFO)))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3513, __FUNCTION__))->typed.type), id);
	goto found;
      }
}
   }
found:;
}
  }
/* Here we diagnose qualified-ids where the scope is actually correct,
   but the identifier does not resolve to a valid type name.  */
else if (parser->scope != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  {
    if (TREE_CODE (parser->scope)((enum tree_code) (parser->scope)->base.code) == NAMESPACE_DECL)
{
 auto_diagnostic_group d;
 name_hint hint;
 if (decl == error_mark_nodeglobal_trees[TI_ERROR_MARK])
   hint = suggest_alternative_in_explicit_scope (location, id,
					  parser->scope);
 const char *suggestion = hint.suggestion ();
 gcc_rich_location richloc (location_of (id));
 if (suggestion)
   richloc.add_fixit_replace (suggestion);
 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
   {
     if (suggestion)
error_at (&richloc,
	  "%qE in namespace %qE does not name a template"
	  " type; did you mean %qs?",
	  id, parser->scope, suggestion);
     else
error_at (&richloc,
	  "%qE in namespace %qE does not name a template type",
	  id, parser->scope);
   }
 else if (TREE_CODE (id)((enum tree_code) (id)->base.code) == TEMPLATE_ID_EXPR)
   {
     if (suggestion)
error_at (&richloc,
	  "%qE in namespace %qE does not name a template"
	  " type; did you mean %qs?",
	  TREE_OPERAND (id, 0)(*((const_cast<tree*> (tree_operand_check ((id), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3554, __FUNCTION__))))), parser->scope, suggestion);
     else
error_at (&richloc,
	  "%qE in namespace %qE does not name a template"
	  " type",
	  TREE_OPERAND (id, 0)(*((const_cast<tree*> (tree_operand_check ((id), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3559, __FUNCTION__))))), parser->scope);
   }
 else
   {
     if (suggestion)
error_at (&richloc,
	  "%qE in namespace %qE does not name a type"
	  "; did you mean %qs?",
	  id, parser->scope, suggestion);
     else
error_at (&richloc,
	  "%qE in namespace %qE does not name a type",
	  id, parser->scope);
   }
 if (DECL_P (decl)(tree_code_type[(int) (((enum tree_code) (decl)->base.code
))] == tcc_declaration))
   inform (DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3574, __FUNCTION__))->decl_minimal.locus), "%qD declared here", decl);
}
    else if (CLASS_TYPE_P (parser->scope)(((((enum tree_code) (parser->scope)->base.code)) == RECORD_TYPE
 || (((enum tree_code) (parser->scope)->base.code)) == UNION_TYPE
) && ((tree_class_check ((parser->scope), (tcc_type
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3576, __FUNCTION__))->type_common.lang_flag_5))
      && constructor_name_p (id, parser->scope))
{
 /* A<T>::A<T>() */
 auto_diagnostic_group d;
 error_at (location, "%<%T::%E%> names the constructor, not"
    " the type", parser->scope, id);
 if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
   error_at (location, "and %qT has no template constructors",
      parser->scope);
}
    else if (TYPE_P (parser->scope)(tree_code_type[(int) (((enum tree_code) (parser->scope)->
base.code))] == tcc_type)
      && dependent_scope_p (parser->scope))
{
 gcc_rich_location richloc (location);
 richloc.add_fixit_insert_before ("typename ");
 if (TREE_CODE (parser->scope)((enum tree_code) (parser->scope)->base.code) == TYPENAME_TYPE)
   error_at (&richloc,
      "need %<typename%> before %<%T::%D::%E%> because "
      "%<%T::%D%> is a dependent scope",
      TYPE_CONTEXT (parser->scope)((tree_class_check ((parser->scope), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3596, __FUNCTION__))->type_common.context),
      TYPENAME_TYPE_FULLNAME (parser->scope)(((tree_class_check (((tree_check ((parser->scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3597, __FUNCTION__, (TYPENAME_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3597, __FUNCTION__))->type_non_common.values)),
      id,
      TYPE_CONTEXT (parser->scope)((tree_class_check ((parser->scope), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3599, __FUNCTION__))->type_common.context),
      TYPENAME_TYPE_FULLNAME (parser->scope)(((tree_class_check (((tree_check ((parser->scope), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3600, __FUNCTION__, (TYPENAME_TYPE)))), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3600, __FUNCTION__))->type_non_common.values)));
 else
   error_at (&richloc, "need %<typename%> before %<%T::%E%> because "
      "%qT is a dependent scope",
      parser->scope, id, parser->scope);
}
    else if (TYPE_P (parser->scope)(tree_code_type[(int) (((enum tree_code) (parser->scope)->
base.code))] == tcc_type))
{
 auto_diagnostic_group d;
 if (!COMPLETE_TYPE_P (parser->scope)(((tree_class_check ((parser->scope), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3609, __FUNCTION__))->type_common.size) != (tree) __null
))
   cxx_incomplete_type_error (location_of (id), NULL_TREE(tree) __null,
		       parser->scope);
 else if (cp_lexer_next_token_is (parser->lexer, CPP_LESS))
   error_at (location_of (id),
      "%qE in %q#T does not name a template type",
      id, parser->scope);
 else if (TREE_CODE (id)((enum tree_code) (id)->base.code) == TEMPLATE_ID_EXPR)
   error_at (location_of (id),
      "%qE in %q#T does not name a template type",
      TREE_OPERAND (id, 0)(*((const_cast<tree*> (tree_operand_check ((id), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3619, __FUNCTION__))))), parser->scope);
 else
   error_at (location_of (id),
      "%qE in %q#T does not name a type",
      id, parser->scope);
 if (DECL_P (decl)(tree_code_type[(int) (((enum tree_code) (decl)->base.code
))] == tcc_declaration))
   inform (DECL_SOURCE_LOCATION (decl)((contains_struct_check ((decl), (TS_DECL_MINIMAL), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3625, __FUNCTION__))->decl_minimal.locus), "%qD declared here", decl);
}
    else
gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 3628, __FUNCTION__));
  }
3630}

3632/* Check for a common situation where a type-name should be present,
 but is not, and issue a sensible error message.  Returns true if an
 invalid type-name was detected.

 The situation handled by this function are variable declarations of the
 form `ID a', where `ID' is an id-expression and `a' is a plain identifier.
 Usually, `ID' should name a type, but if we got here it means that it
 does not. We try to emit the best possible error message depending on
 how exactly the id-expression looks like.  */

3642static bool
3643cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser)
3644{
tree id;
cp_token *token = cp_lexer_peek_token (parser->lexer);

/* Avoid duplicate error about ambiguous lookup.  */
if (token->type == CPP_NESTED_NAME_SPECIFIER((enum cpp_ttype) (((enum cpp_ttype) (CPP_KEYWORD + 1)) + 1)))
  {
    cp_token *next = cp_lexer_peek_nth_token (parser->lexer, 2);
    if (next->type == CPP_NAME && next->error_reported)
goto out;
  }

cp_parser_parse_tentatively (parser);
id = cp_parser_id_expression (parser,
		/*template_keyword_p=*/false,
		/*check_dependency_p=*/true,
		/*template_p=*/NULL__null,
		/*declarator_p=*/false,
		/*optional_p=*/false);
/* If the next token is a (, this is a function with no explicit return
   type, i.e. constructor, destructor or conversion op.  */
if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)
    || TREE_CODE (id)((enum tree_code) (id)->base.code) == TYPE_DECL)
  {
    cp_parser_abort_tentative_parse (parser);
    return false;
  }
if (!cp_parser_parse_definitely (parser))
  return false;

/* Emit a diagnostic for the invalid type.  */
cp_parser_diagnose_invalid_type_name (parser, id, token->location);
out:
/* If we aren't in the middle of a declarator (i.e. in a
   parameter-declaration-clause), skip to the end of the declaration;
   there's no point in trying to process it.  */
if (!parser->in_declarator_p)
  cp_parser_skip_to_end_of_block_or_statement (parser);
return true;
3683}

3685/* Consume tokens up to, and including, the next non-nested closing `)'.
 Returns 1 iff we found a closing `)'.  RECOVERING is true, if we
 are doing error recovery. Returns -1 if OR_TTYPE is not CPP_EOF and we
 found an unnested token of that type.  */

3690static int
3691cp_parser_skip_to_closing_parenthesis_1 (cp_parser *parser,
			 bool recovering,
			 cpp_ttype or_ttype,
			 bool consume_paren)
3695{
unsigned paren_depth = 0;
unsigned brace_depth = 0;
unsigned square_depth = 0;
unsigned condop_depth = 0;

if (recovering && or_ttype == CPP_EOF
    && cp_parser_uncommitted_to_tentative_parse_p (parser))
  return 0;

while (true)
  {
    cp_token * token = cp_lexer_peek_token (parser->lexer);

    /* Have we found what we're looking for before the closing paren?  */
    if (token->type == or_ttype && or_ttype != CPP_EOF
 && !brace_depth && !paren_depth && !square_depth && !condop_depth)
return -1;

    switch (token->type)
{
case CPP_PRAGMA_EOL:
 if (!parser->lexer->in_pragma)
   break;
 /* FALLTHRU */
case CPP_EOF:
 /* If we've run out of tokens, then there is no closing `)'.  */
 return 0;

      /* This is good for lambda expression capture-lists.  */
      case CPP_OPEN_SQUARE:
        ++square_depth;
        break;
      case CPP_CLOSE_SQUARE:
        if (!square_depth--)
          return 0;
        break;

case CPP_SEMICOLON:
 /* This matches the processing in skip_to_end_of_statement.  */
 if (!brace_depth)
   return 0;
 break;

case CPP_OPEN_BRACE:
 ++brace_depth;
 break;
case CPP_CLOSE_BRACE:
 if (!brace_depth--)
   return 0;
 break;

case CPP_OPEN_PAREN:
 if (!brace_depth)
   ++paren_depth;
 break;

case CPP_CLOSE_PAREN:
 if (!brace_depth && !paren_depth--)
   {
     if (consume_paren)
cp_lexer_consume_token (parser->lexer);
     return 1;
   }
 break;

case CPP_QUERY:
 if (!brace_depth && !paren_depth && !square_depth)
   ++condop_depth;
 break;

case CPP_COLON:
 if (!brace_depth && !paren_depth && !square_depth && condop_depth > 0)
   condop_depth--;
 break;

case CPP_KEYWORD:
 if (token->keyword != RID__EXPORT
     && token->keyword != RID__MODULE
     && token->keyword != RID__IMPORT)
   break;
 /* FALLTHROUGH  */

case CPP_PRAGMA:
 /* We fell into a pragma.  Skip it, and continue. */
 cp_parser_skip_to_pragma_eol (parser, recovering ? token : nullptr);
 continue;

default:
 break;
}

    /* Consume the token.  */
    cp_lexer_consume_token (parser->lexer);
  }
3790}

3792/* Consume tokens up to, and including, the next non-nested closing `)'.
 Returns 1 iff we found a closing `)'.  RECOVERING is true, if we
 are doing error recovery. Returns -1 if OR_COMMA is true and we
 found an unnested token of that type.  */

3797static int
3798cp_parser_skip_to_closing_parenthesis (cp_parser *parser,
		       bool recovering,
		       bool or_comma,
		       bool consume_paren)
3802{
cpp_ttype ttype = or_comma ? CPP_COMMA : CPP_EOF;
return cp_parser_skip_to_closing_parenthesis_1 (parser, recovering,
				  ttype, consume_paren);
3806}

3808/* Consume tokens until we reach the end of the current statement.
 Normally, that will be just before consuming a `;'.  However, if a
 non-nested `}' comes first, then we stop before consuming that.  */

3812static void
3813cp_parser_skip_to_end_of_statement (cp_parser* parser)
3814{
unsigned nesting_depth = 0;

/* Unwind generic function template scope if necessary.  */
if (parser->fully_implicit_function_template_p)
  abort_fully_implicit_template (parser);

while (true)
  {
    cp_token *token = cp_lexer_peek_token (parser->lexer);

    switch (token->type)
{
case CPP_PRAGMA_EOL:
 if (!parser->lexer->in_pragma)
   break;
 /* FALLTHRU */
case CPP_EOF:
 /* If we've run out of tokens, stop.  */
 return;

case CPP_SEMICOLON:
 /* If the next token is a `;', we have reached the end of the
    statement.  */
 if (!nesting_depth)
   return;
 break;

case CPP_CLOSE_BRACE:
 /* If this is a non-nested '}', stop before consuming it.
    That way, when confronted with something like:

      { 3 + }

    we stop before consuming the closing '}', even though we
    have not yet reached a `;'.  */
 if (nesting_depth == 0)
   return;

 /* If it is the closing '}' for a block that we have
    scanned, stop -- but only after consuming the token.
    That way given:

void f g () { ... }
typedef int I;

    we will stop after the body of the erroneously declared
    function, but before consuming the following `typedef'
    declaration.  */
 if (--nesting_depth == 0)
   {
     cp_lexer_consume_token (parser->lexer);
     return;
   }
 break;

case CPP_OPEN_BRACE:
 ++nesting_depth;
 break;

case CPP_KEYWORD:
 if (token->keyword != RID__EXPORT
     && token->keyword != RID__MODULE
     && token->keyword != RID__IMPORT)
   break;
 /* FALLTHROUGH  */

case CPP_PRAGMA:
 /* We fell into a pragma.  Skip it, and continue or return. */
 cp_parser_skip_to_pragma_eol (parser, token);
 if (!nesting_depth)
   return;
 continue;

default:
 break;
}

    /* Consume the token.  */
    cp_lexer_consume_token (parser->lexer);
  }
3895}

3897/* This function is called at the end of a statement or declaration.
 If the next token is a semicolon, it is consumed; otherwise, error
 recovery is attempted.  */

3901static void
3902cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser)
3903{
/* Look for the trailing `;'.  */
if (!cp_parser_require (parser, CPP_SEMICOLON, RT_SEMICOLON))
  {
    /* If there is additional (erroneous) input, skip to the end of
the statement.  */
    cp_parser_skip_to_end_of_statement (parser);
    /* If the next token is now a `;', consume it.  */
    if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
cp_lexer_consume_token (parser->lexer);
  }
3914}

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

3919static void
3920cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser)
3921{
int nesting_depth = 0;

/* Unwind generic function template scope if necessary.  */
if (parser->fully_implicit_function_template_p)
  abort_fully_implicit_template (parser);

while (nesting_depth >= 0)
  {
    cp_token *token = cp_lexer_peek_token (parser->lexer);

    switch (token->type)
{
case CPP_PRAGMA_EOL:
 if (!parser->lexer->in_pragma)
   break;
 /* FALLTHRU */
case CPP_EOF:
 /* If we've run out of tokens, stop.  */
 return;

case CPP_SEMICOLON:
 /* Stop if this is an unnested ';'. */
 if (!nesting_depth)
   nesting_depth = -1;
 break;

case CPP_CLOSE_BRACE:
 /* Stop if this is an unnested '}', or closes the outermost
    nesting level.  */
 nesting_depth--;
 if (nesting_depth < 0)
   return;
 if (!nesting_depth)
   nesting_depth = -1;
 break;

case CPP_OPEN_BRACE:
 /* Nest. */
 nesting_depth++;
 break;

case CPP_KEYWORD:
 if (token->keyword != RID__EXPORT
     && token->keyword != RID__MODULE
     && token->keyword != RID__IMPORT)
   break;
 /* FALLTHROUGH  */

case CPP_PRAGMA:
 /* Skip it, and continue or return. */
 cp_parser_skip_to_pragma_eol (parser, token);
 if (!nesting_depth)
   return;
 continue;

default:
 break;
}

    /* Consume the token.  */
    cp_lexer_consume_token (parser->lexer);
  }
3984}

3986/* Skip tokens until a non-nested closing curly brace is the next
 token, or there are no more tokens. Return true in the first case,
 false otherwise.  */

3990static bool
3991cp_parser_skip_to_closing_brace (cp_parser *parser)
3992{
unsigned nesting_depth = 0;

while (true)
  {
    cp_token *token = cp_lexer_peek_token (parser->lexer);

    switch (token->type)
{
case CPP_PRAGMA_EOL:
 if (!parser->lexer->in_pragma)
   break;
 /* FALLTHRU */
case CPP_EOF:
 /* If we've run out of tokens, stop.  */
 return false;

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)
   return true;
 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;

default:
 break;
}

    /* Consume the token.  */
    cp_lexer_consume_token (parser->lexer);
  }
4029}

4031/* Consume tokens until we reach the end of the pragma.  The PRAGMA_TOK
 parameter is the PRAGMA token, allowing us to purge the entire pragma
 sequence.  PRAGMA_TOK can be NULL, if we're speculatively scanning
 forwards (not error recovery).  */

4036static void
4037cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok)
4038{
cp_token *token;

do
  {
    /* The preprocessor makes sure that a PRAGMA_EOL token appears
       before an EOF token, even when the EOF is on the pragma line.
       We should never get here without being inside a deferred
       pragma.  */
    gcc_checking_assert (cp_lexer_next_token_is_not (parser->lexer, CPP_EOF))((void)(!(cp_lexer_next_token_is_not (parser->lexer, CPP_EOF
)) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4047, __FUNCTION__), 0 : 0));
    token = cp_lexer_consume_token (parser->lexer);
  }
while (token->type != CPP_PRAGMA_EOL);

if (pragma_tok)
  {
    /* Ensure that the pragma is not parsed again.  */
    cp_lexer_purge_tokens_after (parser->lexer, pragma_tok);
    parser->lexer->in_pragma = false;
  }
4058}

4060/* Require pragma end of line, resyncing with it as necessary.  The
 arguments are as for cp_parser_skip_to_pragma_eol.  */

4063static void
4064cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok)
4065{
parser->lexer->in_pragma = false;
if (!cp_parser_require (parser, CPP_PRAGMA_EOL, RT_PRAGMA_EOL))
  cp_parser_skip_to_pragma_eol (parser, pragma_tok);
4069}

4071/* This is a simple wrapper around make_typename_type. When the id is
 an unresolved identifier node, we can provide a superior diagnostic
 using cp_parser_diagnose_invalid_type_name.  */

4075static tree
4076cp_parser_make_typename_type (cp_parser *parser, tree id,
	      location_t id_location)
4078{
tree result;
if (identifier_p (id))
  {
    result = make_typename_type (parser->scope, id, typename_type,
		   /*complain=*/tf_none);
    if (result == error_mark_nodeglobal_trees[TI_ERROR_MARK])
cp_parser_diagnose_invalid_type_name (parser, id, id_location);
    return result;
  }
return make_typename_type (parser->scope, id, typename_type, tf_error);
4089}

4091/* This is a wrapper around the
 make_{pointer,ptrmem,reference}_declarator functions that decides
 which one to call based on the CODE and CLASS_TYPE arguments. The
 CODE argument should be one of the values returned by
 cp_parser_ptr_operator.  ATTRIBUTES represent the attributes that
 appertain to the pointer or reference.  */

4098static cp_declarator *
4099cp_parser_make_indirect_declarator (enum tree_code code, tree class_type,
		    cp_cv_quals cv_qualifiers,
		    cp_declarator *target,
		    tree attributes)
4103{
if (code == ERROR_MARK || target == cp_error_declarator)
  return cp_error_declarator;

if (code == INDIRECT_REF)
  if (class_type == NULL_TREE(tree) __null)
    return make_pointer_declarator (cv_qualifiers, target, attributes);
  else
    return make_ptrmem_declarator (cv_qualifiers, class_type,
		     target, attributes);
else if (code == ADDR_EXPR && class_type == NULL_TREE(tree) __null)
  return make_reference_declarator (cv_qualifiers, target,
		      false, attributes);
else if (code == NON_LVALUE_EXPR && class_type == NULL_TREE(tree) __null)
  return make_reference_declarator (cv_qualifiers, target,
		      true, attributes);
gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4119, __FUNCTION__));
4120}

4122/* Create a new C++ parser.  */

4124static cp_parser *
4125cp_parser_new (cp_lexer *lexer)
4126{
/* Initialize the binops_by_token so that we can get the tree
   directly from the token.  */
for (unsigned i = 0; i < sizeof (binops) / sizeof (binops[0]); i++)
  binops_by_token[binops[i].token_type] = binops[i];

cp_parser *parser = ggc_cleared_alloc<cp_parser> ();
parser->lexer = lexer;
parser->context = cp_parser_context_new (NULL__null);

/* For now, we always accept GNU extensions.  */
parser->allow_gnu_extensions_p = 1;

/* The `>' token is a greater-than operator, not the end of a
   template-id.  */
parser->greater_than_is_operator_p = true;

parser->default_arg_ok_p = true;

/* We are not parsing a constant-expression.  */
parser->integral_constant_expression_p = false;
parser->allow_non_integral_constant_expression_p = false;
parser->non_integral_constant_expression_p = false;

/* Local variable names are not forbidden.  */
parser->local_variables_forbidden_p = 0;

/* We are not processing an `extern "C"' declaration.  */
parser->in_unbraced_linkage_specification_p = false;

/* We are not processing a declarator.  */
parser->in_declarator_p = false;

/* We are not processing a template-argument-list.  */
parser->in_template_argument_list_p = false;

/* We are not in an iteration statement.  */
parser->in_statement = 0;

/* We are not in a switch statement.  */
parser->in_switch_statement_p = false;

/* We are not parsing a type-id inside an expression.  */
parser->in_type_id_in_expr_p = false;

/* String literals should be translated to the execution character set.  */
parser->translate_strings_p = true;

/* We are not parsing a function body.  */
parser->in_function_body = false;

/* We can correct until told otherwise.  */
parser->colon_corrects_to_scope_p = true;

/* The unparsed function queue is empty.  */
push_unparsed_function_queues (parser);

/* There are no classes being defined.  */
parser->num_classes_being_defined = 0;

/* No template parameters apply.  */
parser->num_template_parameter_lists = 0;

/* Special parsing data structures.  */
parser->omp_declare_simd = NULL__null;
parser->oacc_routine = NULL__null;

/* Not declaring an implicit function template.  */
parser->auto_is_implicit_function_template_parm_p = false;
parser->fully_implicit_function_template_p = false;
parser->implicit_template_parms = 0;
parser->implicit_template_scope = 0;

/* Allow constrained-type-specifiers. */
parser->prevent_constrained_type_specifiers = 0;

/* We haven't yet seen an 'extern "C"'.  */
parser->innermost_linkage_specification_location = UNKNOWN_LOCATION((location_t) 0);

return parser;
4206}

4208/* Create a cp_lexer structure which will emit the tokens in CACHE
 and push it onto the parser's lexer stack.  This is used for delayed
 parsing of in-class method bodies and default arguments, and should
 not be confused with tentative parsing.  */
4212static void
4213cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache)
4214{
cp_lexer *lexer = cp_lexer_new_from_tokens (cache);
lexer->next = parser->lexer;
parser->lexer = lexer;

/* Move the current source position to that of the first token in the
   new lexer.  */
cp_lexer_set_source_position_from_token (lexer->next_token);
4222}

4224/* Pop the top lexer off the parser stack.  This is never used for the
 "main" lexer, only for those pushed by cp_parser_push_lexer_for_tokens.  */
4226static void
4227cp_parser_pop_lexer (cp_parser *parser)
4228{
cp_lexer *lexer = parser->lexer;
parser->lexer = lexer->next;
cp_lexer_destroy (lexer);

/* Put the current source position back where it was before this
   lexer was pushed.  */
cp_lexer_set_source_position_from_token (parser->lexer->next_token);
4236}

4238/* Lexical conventions [gram.lex]  */

4240/* Parse an identifier.  Returns an IDENTIFIER_NODE representing the
 identifier.  */

4243static cp_expr
4244cp_parser_identifier (cp_parser* parser)
4245{
cp_token *token;

/* Look for the identifier.  */
token = cp_parser_require (parser, CPP_NAME, RT_NAME);
/* Return the value.  */
if (token)
  return cp_expr (token->u.value, token->location);
else
  return error_mark_nodeglobal_trees[TI_ERROR_MARK];
4255}

4257/* Parse a sequence of adjacent string constants.  Returns a
 TREE_STRING representing the combined, nul-terminated string
 constant.  If TRANSLATE is true, translate the string to the
 execution character set.  If WIDE_OK is true, a wide string is
 invalid here.

 C++98 [lex.string] says that if a narrow string literal token is
 adjacent to a wide string literal token, the behavior is undefined.
 However, C99 6.4.5p4 says that this results in a wide string literal.
 We follow C99 here, for consistency with the C front end.

 This code is largely lifted from lex_string() in c-lex.c.

 FUTURE: ObjC++ will need to handle @-strings here.  */
4271static cp_expr
4272cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok,
	  bool lookup_udlit = true)
4274{
tree value;
size_t count;
struct obstack str_ob;
struct obstack loc_ob;
cpp_string str, istr, *strs;
cp_token *tok;
enum cpp_ttype type, curr_type;
int have_suffix_p = 0;
tree string_tree;
tree suffix_id = NULL_TREE(tree) __null;
bool curr_tok_is_userdef_p = false;

tok = cp_lexer_peek_token (parser->lexer);
if (!cp_parser_is_string_literal (tok))
  {
    cp_parser_error (parser, "expected string-literal");
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }

location_t loc = tok->location;

if (cpp_userdef_string_p (tok->type))
  {
    string_tree = USERDEF_LITERAL_VALUE (tok->u.value)(((struct tree_userdef_literal *)(tree_check ((tok->u.value
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4298, __FUNCTION__, (USERDEF_LITERAL))))->value);
    curr_type = cpp_userdef_string_remove_type (tok->type);
    curr_tok_is_userdef_p = true;
  }
else
  {
    string_tree = tok->u.value;
    curr_type = tok->type;
  }
type = curr_type;

/* Try to avoid the overhead of creating and destroying an obstack
   for the common case of just one string.  */
if (!cp_parser_is_string_literal
    (cp_lexer_peek_nth_token (parser->lexer, 2)))
  {
    cp_lexer_consume_token (parser->lexer);

    str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree)((const char *)((tree_check ((string_tree), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4316, __FUNCTION__, (STRING_CST)))->string.str));
    str.len = TREE_STRING_LENGTH (string_tree)((tree_check ((string_tree), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4317, __FUNCTION__, (STRING_CST)))->string.length);
    count = 1;

    if (curr_tok_is_userdef_p)
{
 suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value)(((struct tree_userdef_literal *)(tree_check ((tok->u.value
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4322, __FUNCTION__, (USERDEF_LITERAL))))->suffix_id);
 have_suffix_p = 1;
 curr_type = cpp_userdef_string_remove_type (tok->type);
}
    else
curr_type = tok->type;

    strs = &str;
  }
else
  {
    location_t last_tok_loc = tok->location;
    gcc_obstack_init (&str_ob)_obstack_begin (((&str_ob)), (memory_block_pool::block_size
), (0), (mempool_obstack_chunk_alloc), (mempool_obstack_chunk_free
));
    gcc_obstack_init (&loc_ob)_obstack_begin (((&loc_ob)), (memory_block_pool::block_size
), (0), (mempool_obstack_chunk_alloc), (mempool_obstack_chunk_free
));
    count = 0;

    do
{
 cp_lexer_consume_token (parser->lexer);
 count++;
 str.text = (const unsigned char *)TREE_STRING_POINTER (string_tree)((const char *)((tree_check ((string_tree), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4342, __FUNCTION__, (STRING_CST)))->string.str));
 str.len = TREE_STRING_LENGTH (string_tree)((tree_check ((string_tree), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4343, __FUNCTION__, (STRING_CST)))->string.length);

 if (curr_tok_is_userdef_p)
   {
     tree curr_suffix_id = USERDEF_LITERAL_SUFFIX_ID (tok->u.value)(((struct tree_userdef_literal *)(tree_check ((tok->u.value
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4347, __FUNCTION__, (USERDEF_LITERAL))))->suffix_id);
     if (have_suffix_p == 0)
{
  suffix_id = curr_suffix_id;
  have_suffix_p = 1;
}
     else if (have_suffix_p == 1
       && curr_suffix_id != suffix_id)
{
  error ("inconsistent user-defined literal suffixes"
	 " %qD and %qD in string literal",
	 suffix_id, curr_suffix_id);
  have_suffix_p = -1;
}
     curr_type = cpp_userdef_string_remove_type (tok->type);
   }
 else
   curr_type = tok->type;

 if (type != curr_type)
   {
     if (type == CPP_STRING)
type = curr_type;
     else if (curr_type != CPP_STRING)
{
  rich_location rich_loc (line_table, tok->location);
  rich_loc.add_range (last_tok_loc);
  error_at (&rich_loc,
	    "unsupported non-standard concatenation "
	    "of string literals");
}
   }

 obstack_grow (&str_ob, &str, sizeof (cpp_string))__extension__ ({ struct obstack *__o = (&str_ob); size_t __len
 = (sizeof (cpp_string)); if (__extension__ ({ struct obstack
 const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
 (__o->next_free, &str, __len); __o->next_free += __len
; (void) 0; });
 obstack_grow (&loc_ob, &tok->location, sizeof (location_t))__extension__ ({ struct obstack *__o = (&loc_ob); size_t __len
 = (sizeof (location_t)); if (__extension__ ({ struct obstack
 const *__o1 = (__o); (size_t) (__o1->chunk_limit - __o1->
next_free); }) < __len) _obstack_newchunk (__o, __len); memcpy
 (__o->next_free, &tok->location, __len); __o->next_free
 += __len; (void) 0; });

 last_tok_loc = tok->location;

 tok = cp_lexer_peek_token (parser->lexer);
 if (cpp_userdef_string_p (tok->type))
   {
     string_tree = USERDEF_LITERAL_VALUE (tok->u.value)(((struct tree_userdef_literal *)(tree_check ((tok->u.value
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4388, __FUNCTION__, (USERDEF_LITERAL))))->value);
     curr_type = cpp_userdef_string_remove_type (tok->type);
     curr_tok_is_userdef_p = true;
   }
 else
   {
     string_tree = tok->u.value;
     curr_type = tok->type;
     curr_tok_is_userdef_p = false;
   }
}
    while (cp_parser_is_string_literal (tok));

    /* A string literal built by concatenation has its caret=start at
the start of the initial string, and its finish at the finish of
the final string literal.  */
    loc = make_location (loc, loc, get_finish (last_tok_loc));

    strs = (cpp_string *) obstack_finish (&str_ob)__extension__ ({ struct obstack *__o1 = (&str_ob); 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; });
  }

if (type != CPP_STRING && !wide_ok)
  {
    cp_parser_error (parser, "a wide string is invalid in this context");
    type = CPP_STRING;
  }

if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate)
    (parse_in, strs, count, &istr, type))
  {
    value = build_string (istr.len, (const char *)istr.text);
    free (CONST_CAST (unsigned char *, istr.text)(const_cast<unsigned char *> ((istr.text))));
    if (count > 1)
{
 location_t *locs = (location_t *)obstack_finish (&loc_ob)__extension__ ({ struct obstack *__o1 = (&loc_ob); 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; });
 gcc_assert (g_string_concat_db)((void)(!(g_string_concat_db) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4423, __FUNCTION__), 0 : 0));
 g_string_concat_db->record_string_concatenation (count, locs);
}

    switch (type)
{
default:
case CPP_STRING:
 TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4431, __FUNCTION__))->typed.type) = char_array_type_nodec_global_trees[CTI_CHAR_ARRAY_TYPE];
 break;
case CPP_UTF8STRING:
 if (flag_char8_tglobal_options.x_flag_char8_t)
   TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4435, __FUNCTION__))->typed.type) = char8_array_type_nodec_global_trees[CTI_CHAR8_ARRAY_TYPE];
 else
   TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4437, __FUNCTION__))->typed.type) = char_array_type_nodec_global_trees[CTI_CHAR_ARRAY_TYPE];
 break;
case CPP_STRING16:
 TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4440, __FUNCTION__))->typed.type) = char16_array_type_nodec_global_trees[CTI_CHAR16_ARRAY_TYPE];
 break;
case CPP_STRING32:
 TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4443, __FUNCTION__))->typed.type) = char32_array_type_nodec_global_trees[CTI_CHAR32_ARRAY_TYPE];
 break;
case CPP_WSTRING:
 TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4446, __FUNCTION__))->typed.type) = wchar_array_type_nodec_global_trees[CTI_WCHAR_ARRAY_TYPE];
 break;
}

    value = fix_string_type (value);

    if (have_suffix_p)
{
 tree literal = build_userdef_literal (suffix_id, value,
				OT_NONE, NULL_TREE(tree) __null);
 if (lookup_udlit)
   value = cp_parser_userdef_string_literal (literal);
 else
   value = literal;
}
  }
else
  /* cpp_interpret_string has issued an error.  */
  value = error_mark_nodeglobal_trees[TI_ERROR_MARK];

if (count > 1)
  {
    obstack_free (&str_ob, 0)__extension__ ({ struct obstack *__o = (&str_ob); void *__obj
 = (void *) (0); if (__obj > (void *) __o->chunk &&
 __obj < (void *) __o->chunk_limit) __o->next_free =
 __o->object_base = (char *) __obj; else _obstack_free (__o
, __obj); });
    obstack_free (&loc_ob, 0)__extension__ ({ struct obstack *__o = (&loc_ob); void *__obj
 = (void *) (0); if (__obj > (void *) __o->chunk &&
 __obj < (void *) __o->chunk_limit) __o->next_free =
 __o->object_base = (char *) __obj; else _obstack_free (__o
, __obj); });
  }

return cp_expr (value, loc);
4473}

4475/* Look up a literal operator with the name and the exact arguments.  */

4477static tree
4478lookup_literal_operator (tree name, vec<tree, va_gc> *args)
4479{
tree decl = lookup_name (name);
if (!decl || !is_overloaded_fn (decl))
  return error_mark_nodeglobal_trees[TI_ERROR_MARK];

for (lkp_iterator iter (decl); iter; ++iter)
  {
    tree fn = *iter;

    if (tree parmtypes = TYPE_ARG_TYPES (TREE_TYPE (fn))((tree_check2 ((((contains_struct_check ((fn), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4488, __FUNCTION__))->typed.type)), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4488, __FUNCTION__, (FUNCTION_TYPE), (METHOD_TYPE)))->type_non_common
.values))
{
 unsigned int ix;
 bool found = true;

 for (ix = 0;
      found && ix < vec_safe_length (args) && parmtypes != NULL_TREE(tree) __null;
      ++ix, parmtypes = TREE_CHAIN (parmtypes)((contains_struct_check ((parmtypes), (TS_COMMON), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4495, __FUNCTION__))->common.chain))
   {
     tree tparm = TREE_VALUE (parmtypes)((tree_check ((parmtypes), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4497, __FUNCTION__, (TREE_LIST)))->list.value);
     tree targ = TREE_TYPE ((*args)[ix])((contains_struct_check (((*args)[ix]), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4498, __FUNCTION__))->typed.type);
     bool ptr = TYPE_PTR_P (tparm)(((enum tree_code) (tparm)->base.code) == POINTER_TYPE);
     bool arr = TREE_CODE (targ)((enum tree_code) (targ)->base.code) == ARRAY_TYPE;
     if ((ptr || arr || !same_type_p (tparm, targ)comptypes ((tparm), (targ), 0))
  && (!ptr || !arr
      || !same_type_p (TREE_TYPE (tparm),comptypes ((((contains_struct_check ((tparm), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4503, __FUNCTION__))->typed.type)), (((contains_struct_check
 ((targ), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4504, __FUNCTION__))->typed.type)), 0)
		       TREE_TYPE (targ))comptypes ((((contains_struct_check ((tparm), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4503, __FUNCTION__))->typed.type)), (((contains_struct_check
 ((targ), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4504, __FUNCTION__))->typed.type)), 0)))
found = false;
   }

 if (found
     && ix == vec_safe_length (args)
     /* May be this should be sufficient_parms_p instead,
 depending on how exactly should user-defined literals
 work in presence of default arguments on the literal
 operator parameters.  */
     && parmtypes == void_list_nodeglobal_trees[TI_VOID_LIST_NODE])
   return decl;
}
  }

return error_mark_nodeglobal_trees[TI_ERROR_MARK];
4520}

4522/* Parse a user-defined char constant.  Returns a call to a user-defined
 literal operator taking the character as an argument.  */

4525static cp_expr
4526cp_parser_userdef_char_literal (cp_parser *parser)
4527{
cp_token *token = cp_lexer_consume_token (parser->lexer);
tree literal = token->u.value;
tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal)(((struct tree_userdef_literal *)(tree_check ((literal), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4530, __FUNCTION__, (USERDEF_LITERAL))))->suffix_id);
tree value = USERDEF_LITERAL_VALUE (literal)(((struct tree_userdef_literal *)(tree_check ((literal), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4531, __FUNCTION__, (USERDEF_LITERAL))))->value);
tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id)((const char *) (tree_check ((suffix_id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4532, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
tree decl, result;

/* Build up a call to the user-defined operator  */
/* Lookup the name we got back from the id-expression.  */
releasing_vec args;
vec_safe_push (args, value);
decl = lookup_literal_operator (name, args);
if (!decl || decl == error_mark_nodeglobal_trees[TI_ERROR_MARK])
  {
    error ("unable to find character literal operator %qD with %qT argument",
    name, TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4543, __FUNCTION__))->typed.type));
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }
result = finish_call_expr (decl, &args, false, true, tf_warning_or_error);
return result;
4548}

4550/* A subroutine of cp_parser_userdef_numeric_literal to
 create a char... template parameter pack from a string node.  */

4553static tree
4554make_char_string_pack (tree value)
4555{
tree charvec;
tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
const char *str = TREE_STRING_POINTER (value)((const char *)((tree_check ((value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4558, __FUNCTION__, (STRING_CST)))->string.str));
int i, len = TREE_STRING_LENGTH (value)((tree_check ((value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4559, __FUNCTION__, (STRING_CST)))->string.length) - 1;
tree argvec = make_tree_vec (1);

/* Fill in CHARVEC with all of the parameters.  */
charvec = make_tree_vec (len);
for (i = 0; i < len; ++i)
  {
    unsigned char s[3] = { '\'', str[i], '\'' };
    cpp_string in = { 3, s };
    cpp_string out = { 0, 0 };
    if (!cpp_interpret_string (parse_in, &in, 1, &out, CPP_STRING))
return NULL_TREE(tree) __null;
    gcc_assert (out.len == 2)((void)(!(out.len == 2) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4571, __FUNCTION__), 0 : 0));
    TREE_VEC_ELT (charvec, i)(*((const_cast<tree *> (tree_vec_elt_check ((charvec), (
i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4572, __FUNCTION__))))) = build_int_cst (char_type_nodeinteger_types[itk_char],
				 out.text[0]);
  }

/* Build the argument packs.  */
SET_ARGUMENT_PACK_ARGS (argpack, charvec)if (((enum tree_code) (argpack)->base.code) == TYPE_ARGUMENT_PACK
) ((contains_struct_check ((argpack), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4577, __FUNCTION__))->typed.type) = charvec; else (*((const_cast
<tree*> (tree_operand_check ((argpack), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4577, __FUNCTION__))))) = charvec;

TREE_VEC_ELT (argvec, 0)(*((const_cast<tree *> (tree_vec_elt_check ((argvec), (
0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4579, __FUNCTION__))))) = argpack;

return argvec;
4582}

4584/* A subroutine of cp_parser_userdef_numeric_literal to
 create a char... template parameter pack from a string node.  */

4587static tree
4588make_string_pack (tree value)
4589{
tree charvec;
tree argpack = make_node (NONTYPE_ARGUMENT_PACK);
const unsigned char *str
  = (const unsigned char *) TREE_STRING_POINTER (value)((const char *)((tree_check ((value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4593, __FUNCTION__, (STRING_CST)))->string.str));
int sz = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value))))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((((contains_struct_check ((((contains_struct_check ((value)
, (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4594, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4594, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4594, __FUNCTION__))->type_common.size_unit)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4594, __FUNCTION__)));
int len = TREE_STRING_LENGTH (value)((tree_check ((value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4595, __FUNCTION__, (STRING_CST)))->string.length) / sz - 1;
tree argvec = make_tree_vec (2);

tree str_char_type_node = TREE_TYPE (TREE_TYPE (value))((contains_struct_check ((((contains_struct_check ((value), (
TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4598, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4598, __FUNCTION__))->typed.type);
str_char_type_node = TYPE_MAIN_VARIANT (str_char_type_node)((tree_class_check ((str_char_type_node), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4599, __FUNCTION__))->type_common.main_variant);

/* First template parm is character type.  */
TREE_VEC_ELT (argvec, 0)(*((const_cast<tree *> (tree_vec_elt_check ((argvec), (
0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4602, __FUNCTION__))))) = str_char_type_node;

/* Fill in CHARVEC with all of the parameters.  */
charvec = make_tree_vec (len);
for (int i = 0; i < len; ++i)
  TREE_VEC_ELT (charvec, i)(*((const_cast<tree *> (tree_vec_elt_check ((charvec), (
i), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4607, __FUNCTION__)))))
    = double_int_to_tree (str_char_type_node,
	    double_int::from_buffer (str + i * sz, sz));

/* Build the argument packs.  */
SET_ARGUMENT_PACK_ARGS (argpack, charvec)if (((enum tree_code) (argpack)->base.code) == TYPE_ARGUMENT_PACK
) ((contains_struct_check ((argpack), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4612, __FUNCTION__))->typed.type) = charvec; else (*((const_cast
<tree*> (tree_operand_check ((argpack), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4612, __FUNCTION__))))) = charvec;

TREE_VEC_ELT (argvec, 1)(*((const_cast<tree *> (tree_vec_elt_check ((argvec), (
1), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4614, __FUNCTION__))))) = argpack;

return argvec;
4617}

4619/* Parse a user-defined numeric constant.  returns a call to a user-defined
 literal operator.  */

4622static cp_expr
4623cp_parser_userdef_numeric_literal (cp_parser *parser)
4624{
cp_token *token = cp_lexer_consume_token (parser->lexer);
tree literal = token->u.value;
tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal)(((struct tree_userdef_literal *)(tree_check ((literal), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4627, __FUNCTION__, (USERDEF_LITERAL))))->suffix_id);
tree value = USERDEF_LITERAL_VALUE (literal)(((struct tree_userdef_literal *)(tree_check ((literal), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4628, __FUNCTION__, (USERDEF_LITERAL))))->value);
int overflow = USERDEF_LITERAL_OVERFLOW (literal)(((struct tree_userdef_literal *)(tree_check ((literal), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4629, __FUNCTION__, (USERDEF_LITERAL))))->overflow);
tree num_string = USERDEF_LITERAL_NUM_STRING (literal)(((struct tree_userdef_literal *)(tree_check ((literal), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4630, __FUNCTION__, (USERDEF_LITERAL))))->num_string);
tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id)((const char *) (tree_check ((suffix_id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4631, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
tree decl, result;

/* Look for a literal operator taking the exact type of numeric argument
   as the literal value.  */
releasing_vec args;
vec_safe_push (args, value);
decl = lookup_literal_operator (name, args);
if (decl && decl != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  {
    result = finish_call_expr (decl, &args, false, true,
		 tf_warning_or_error);

    if (TREE_CODE (TREE_TYPE (value))((enum tree_code) (((contains_struct_check ((value), (TS_TYPED
), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4644, __FUNCTION__))->typed.type))->base.code) == INTEGER_TYPE && overflow > 0)
{
 warning_at (token->location, OPT_Woverflow,
      "integer literal exceeds range of %qT type",
      long_long_unsigned_type_nodeinteger_types[itk_unsigned_long_long]);
}
    else
{
 if (overflow > 0)
   warning_at (token->location, OPT_Woverflow,
	"floating literal exceeds range of %qT type",
	long_double_type_nodeglobal_trees[TI_LONG_DOUBLE_TYPE]);
 else if (overflow < 0)
   warning_at (token->location, OPT_Woverflow,
	"floating literal truncated to zero");
}

    return result;
  }

/* If the numeric argument didn't work, look for a raw literal
   operator taking a const char* argument consisting of the number
   in string format.  */
args->truncate (0);
vec_safe_push (args, num_string);
decl = lookup_literal_operator (name, args);
if (decl && decl != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  {
    result = finish_call_expr (decl, &args, false, true,
		 tf_warning_or_error);
    return result;
  }

/* If the raw literal didn't work, look for a non-type template
   function with parameter pack char....  Call the function with
   template parameter characters representing the number.  */
args->truncate (0);
decl = lookup_literal_operator (name, args);
if (decl && decl != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  {
    tree tmpl_args = make_char_string_pack (num_string);
    if (tmpl_args == NULL_TREE(tree) __null)
{
 error ("failed to translate literal to execution character set %qT",
 num_string);
 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
}
    decl = lookup_template_function (decl, tmpl_args);
    result = finish_call_expr (decl, &args, false, true,
		 tf_warning_or_error);
    return result;
  }

/* In C++14 the standard library defines complex number suffixes that
   conflict with GNU extensions.  Prefer them if <complex> is #included.  */
bool ext = cpp_get_options (parse_in)->ext_numeric_literals;
bool i14 = (cxx_dialect > cxx11
     && (id_equal (suffix_id, "i")
  || id_equal (suffix_id, "if")
  || id_equal (suffix_id, "il")));
diagnostic_t kind = DK_ERROR;
int opt = 0;

if (i14 && ext)
  {
    tree cxlit = lookup_qualified_name (std_nodecp_global_trees[CPTI_STD], "complex_literals",
			  LOOK_want::NORMAL, false);
    if (cxlit == error_mark_nodeglobal_trees[TI_ERROR_MARK])
{
 /* No <complex>, so pedwarn and use GNU semantics.  */
 kind = DK_PEDWARN;
 opt = OPT_Wpedantic;
}
  }

bool complained
  = emit_diagnostic (kind, input_location, opt,
       "unable to find numeric literal operator %qD", name);

if (!complained)
  /* Don't inform either.  */;
else if (i14)
  {
    inform (token->location, "add %<using namespace std::complex_literals%> "
     "(from %<<complex>%>) to enable the C++14 user-defined literal "
     "suffixes");
    if (ext)
inform (token->location, "or use %<j%> instead of %<i%> for the "
"GNU built-in suffix");
  }
else if (!ext)
  inform (token->location, "use %<-fext-numeric-literals%> "
   "to enable more built-in suffixes");

if (kind == DK_ERROR)
  value = error_mark_nodeglobal_trees[TI_ERROR_MARK];
else
  {
    /* Use the built-in semantics.  */
    tree type;
    if (id_equal (suffix_id, "i"))
{
 if (TREE_CODE (value)((enum tree_code) (value)->base.code) == INTEGER_CST)
   type = integer_type_nodeinteger_types[itk_int];
 else
   type = double_type_nodeglobal_trees[TI_DOUBLE_TYPE];
}
    else if (id_equal (suffix_id, "if"))
type = float_type_nodeglobal_trees[TI_FLOAT_TYPE];
    else /* if (id_equal (suffix_id, "il")) */
type = long_double_type_nodeglobal_trees[TI_LONG_DOUBLE_TYPE];

    value = build_complex (build_complex_type (type),
	     fold_convert (type, integer_zero_node)fold_convert_loc (((location_t) 0), type, global_trees[TI_INTEGER_ZERO
]),
	     fold_convert (type, value)fold_convert_loc (((location_t) 0), type, value));
  }

if (cp_parser_uncommitted_to_tentative_parse_p (parser))
  /* Avoid repeated diagnostics.  */
  token->u.value = value;
return value;
4765}

4767/* Parse a user-defined string constant.  Returns a call to a user-defined
 literal operator taking a character pointer and the length of the string
 as arguments.  */

4771static tree
4772cp_parser_userdef_string_literal (tree literal)
4773{
tree suffix_id = USERDEF_LITERAL_SUFFIX_ID (literal)(((struct tree_userdef_literal *)(tree_check ((literal), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4774, __FUNCTION__, (USERDEF_LITERAL))))->suffix_id);
tree name = cp_literal_operator_id (IDENTIFIER_POINTER (suffix_id)((const char *) (tree_check ((suffix_id), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4775, __FUNCTION__, (IDENTIFIER_NODE)))->identifier.id.str
));
tree value = USERDEF_LITERAL_VALUE (literal)(((struct tree_userdef_literal *)(tree_check ((literal), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4776, __FUNCTION__, (USERDEF_LITERAL))))->value);
int len = TREE_STRING_LENGTH (value)((tree_check ((value), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4777, __FUNCTION__, (STRING_CST)))->string.length)
/ TREE_INT_CST_LOW (TYPE_SIZE_UNIT (TREE_TYPE (TREE_TYPE (value))))((unsigned long) (*tree_int_cst_elt_check ((((tree_class_check
 ((((contains_struct_check ((((contains_struct_check ((value)
, (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4778, __FUNCTION__))->typed.type)), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4778, __FUNCTION__))->typed.type)), (tcc_type), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4778, __FUNCTION__))->type_common.size_unit)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4778, __FUNCTION__))) - 1;
tree decl;

/* Build up a call to the user-defined operator.  */
/* Lookup the name we got back from the id-expression.  */
releasing_vec args;
vec_safe_push (args, value);
vec_safe_push (args, build_int_cst (size_type_nodeglobal_trees[TI_SIZE_TYPE], len));
decl = lookup_literal_operator (name, args);

if (decl && decl != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  return finish_call_expr (decl, &args, false, true,
	     tf_warning_or_error);

/* Look for a suitable template function, either (C++20) with a single
   parameter of class type, or (N3599) with typename parameter CharT and
   parameter pack CharT...  */
args->truncate (0);
decl = lookup_literal_operator (name, args);
if (decl && decl != error_mark_nodeglobal_trees[TI_ERROR_MARK])
  {
    /* Use resolve_nondeduced_context to try to choose one form of template
or the other.  */
    tree tmpl_args = make_tree_vec (1);
    TREE_VEC_ELT (tmpl_args, 0)(*((const_cast<tree *> (tree_vec_elt_check ((tmpl_args)
, (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4802, __FUNCTION__))))) = value;
    decl = lookup_template_function (decl, tmpl_args);
    tree res = resolve_nondeduced_context (decl, tf_none);
    if (DECL_P (res)(tree_code_type[(int) (((enum tree_code) (res)->base.code)
)] == tcc_declaration))
decl = res;
    else
{
 TREE_OPERAND (decl, 1)(*((const_cast<tree*> (tree_operand_check ((decl), (1),
 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4809, __FUNCTION__))))) = make_string_pack (value);
 res = resolve_nondeduced_context (decl, tf_none);
 if (DECL_P (res)(tree_code_type[(int) (((enum tree_code) (res)->base.code)
)] == tcc_declaration))
   decl = res;
}
    if (!DECL_P (decl)(tree_code_type[(int) (((enum tree_code) (decl)->base.code
))] == tcc_declaration) && cxx_dialect > cxx17)
TREE_OPERAND (decl, 1)(*((const_cast<tree*> (tree_operand_check ((decl), (1),
 "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4815, __FUNCTION__))))) = tmpl_args;
    return finish_call_expr (decl, &args, false, true,
	       tf_warning_or_error);
  }

error ("unable to find string literal operator %qD with %qT, %qT arguments",
name, TREE_TYPE (value)((contains_struct_check ((value), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4821, __FUNCTION__))->typed.type), size_type_nodeglobal_trees[TI_SIZE_TYPE]);
return error_mark_nodeglobal_trees[TI_ERROR_MARK];
4823}


4826/* Basic concepts [gram.basic]  */

4828/* Parse a translation-unit.

 translation-unit:
   declaration-seq [opt]  */

4833static void
4834cp_parser_translation_unit (cp_parser* parser)
4835{
gcc_checking_assert (!cp_error_declarator)((void)(!(!cp_error_declarator) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4836, __FUNCTION__), 0 : 0));

/* Create the declarator obstack.  */
gcc_obstack_init (&declarator_obstack)_obstack_begin (((&declarator_obstack)), (memory_block_pool
::block_size), (0), (mempool_obstack_chunk_alloc), (mempool_obstack_chunk_free
));
/* Create the error declarator.  */
cp_error_declarator = make_declarator (cdk_error);
/* Create the empty parameter list.  */
no_parameters = make_parameter_declarator (NULL__null, NULL__null, NULL_TREE(tree) __null,
			     UNKNOWN_LOCATION((location_t) 0));
/* Remember where the base of the declarator obstack lies.  */
void *declarator_obstack_base = obstack_next_free (&declarator_obstack)((void *) (&declarator_obstack)->next_free);

push_deferring_access_checks (flag_access_controlglobal_options.x_flag_access_control
		? dk_no_deferred : dk_no_check);

module_parse mp_state = MP_NOT_MODULE;
if (modules_p () && !header_module_p ())
  mp_state = MP_FIRST;

bool implicit_extern_c = false;

/* Parse until EOF.  */
for (;;)
  {
    cp_token *token = cp_lexer_peek_token (parser->lexer);

    /* If we're entering or exiting a region that's implicitly
extern "C", modify the lang context appropriately.  This is
so horrible.  Please die.   */
    if (implicit_extern_c
 != cp_lexer_peek_token (parser->lexer)->implicit_extern_c)
{
 implicit_extern_c = !implicit_extern_c;
 if (implicit_extern_c)
   push_lang_context (lang_name_ccp_global_trees[CPTI_LANG_NAME_C]);
 else
   pop_lang_context ();
}

    if (token->type == CPP_EOF)
break;

    if (modules_p ())
{
 /* Top-level module declarations are ok, and change the
    portion of file we're in.  Top-level import declarations
    are significant for the import portions.  */

 cp_token *next = token;
 bool exporting = token->keyword == RID__EXPORT;
 if (exporting)
   {
     cp_lexer_consume_token (parser->lexer);
     next = cp_lexer_peek_token (parser->lexer);
   }
 if (next->keyword == RID__MODULE)
   {
     mp_state
= cp_parser_module_declaration (parser, mp_state, exporting);
     continue;
   }
 else if (next->keyword == RID__IMPORT)
   {
     if (mp_state == MP_FIRST)
mp_state = MP_NOT_MODULE;
     cp_parser_import_declaration (parser, mp_state, exporting);
     continue;
   }
 else
   gcc_checking_assert (!exporting)((void)(!(!exporting) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4905, __FUNCTION__), 0 : 0));

 if (mp_state == MP_GLOBAL && token->main_source_p)
   {
     static bool warned = false;
     if (!warned)
{
  warned = true;
  error_at (token->location,
	    "global module fragment contents must be"
	    " from preprocessor inclusion");
}
   }
}

    /* This relies on the ordering of module_parse values.  */
    if (mp_state == MP_PURVIEW_IMPORTS || mp_state == MP_PRIVATE_IMPORTS)
/* We're no longer in the import portion of a named module.  */
mp_state = module_parse (mp_state + 1);
    else if (mp_state == MP_FIRST)
mp_state = MP_NOT_MODULE;

    if (token->type == CPP_CLOSE_BRACE)
{
 cp_parser_error (parser, "expected declaration");
 cp_lexer_consume_token (parser->lexer);
 /* If the next token is now a `;', consume it.  */
 if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))
   cp_lexer_consume_token (parser->lexer);
}
    else
cp_parser_toplevel_declaration (parser);
  }

/* Get rid of the token array; we don't need it any more.  */
cp_lexer_destroy (parser->lexer);
parser->lexer = NULL__null;

/* The EOF should have reset this. */
gcc_checking_assert (!implicit_extern_c)((void)(!(!implicit_extern_c) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4944, __FUNCTION__), 0 : 0));

/* Make sure the declarator obstack was fully cleaned up.  */
gcc_assert (obstack_next_free (&declarator_obstack)((void)(!(((void *) (&declarator_obstack)->next_free) ==
 declarator_obstack_base) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4948, __FUNCTION__), 0 : 0))
     == declarator_obstack_base)((void)(!(((void *) (&declarator_obstack)->next_free) ==
 declarator_obstack_base) ? fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 4948, __FUNCTION__), 0 : 0));
4949}

4951/* Return the appropriate tsubst flags for parsing, possibly in N3276
 decltype context.  */

4954static inline tsubst_flags_t
4955complain_flags (bool decltype_p)
4956{
tsubst_flags_t complain = tf_warning_or_error;
if (decltype_p)
  complain |= tf_decltype;
return complain;
4961}

4963/* We're about to parse a collection of statements.  If we're currently
 parsing tentatively, set up a firewall so that any nested
 cp_parser_commit_to_tentative_parse won't affect the current context.  */

4967static cp_token_position
4968cp_parser_start_tentative_firewall (cp_parser *parser)
4969{
if (!cp_parser_uncommitted_to_tentative_parse_p (parser))
  return 0;

cp_parser_parse_tentatively (parser);
cp_parser_commit_to_topmost_tentative_parse (parser);
return cp_lexer_token_position (parser->lexer, false);
4976}

4978/* We've finished parsing the collection of statements.  Wrap up the
 firewall and replace the relevant tokens with the parsed form.  */

4981static void
4982cp_parser_end_tentative_firewall (cp_parser *parser, cp_token_position start,
		  tree expr)
4984{
if (!start)
  return;

/* Finish the firewall level.  */
cp_parser_parse_definitely (parser);
/* And remember the result of the parse for when we try again.  */
cp_token *token = cp_lexer_token_at (parser->lexer, start);
token->type = CPP_PREPARSED_EXPR((enum cpp_ttype) (((enum cpp_ttype) (((enum cpp_ttype) (((enum
 cpp_ttype) (CPP_KEYWORD + 1)) + 1)) + 1)) + 1));
token->u.value = expr;
token->keyword = RID_MAX;
cp_lexer_purge_tokens_after (parser->lexer, start);
4996}

4998/* Like the above functions, but let the user modify the tokens.  Used by
 CPP_DECLTYPE and CPP_TEMPLATE_ID, where we are saving the side-effects for
 later parses, so it makes sense to localize the effects of
 cp_parser_commit_to_tentative_parse.  */

5003struct tentative_firewall
5004{
cp_parser *parser;
bool set;

tentative_firewall (cp_parser *p): parser(p)
{
  /* If we're currently parsing tentatively, start a committed level as a
     firewall and then an inner tentative parse.  */
  if ((set = cp_parser_uncommitted_to_tentative_parse_p (parser)))
    {
cp_parser_parse_tentatively (parser);
cp_parser_commit_to_topmost_tentative_parse (parser);
cp_parser_parse_tentatively (parser);
    }
}

~tentative_firewall()
{
  if (set)
    {
/* Finish the inner tentative parse and the firewall, propagating any
  uncommitted error state to the outer tentative parse.  */
bool err = cp_parser_error_occurred (parser);
cp_parser_parse_definitely (parser);
cp_parser_parse_definitely (parser);
if (err)
 cp_parser_simulate_error (parser);
    }
}
5033};

5035/* 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.  */

5042template <typename traits_t>
5043class token_pair
5044{
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 (cp_parser *parser)
{
  m_open_loc = cp_lexer_peek_token (parser->lexer)->location;
  return cp_parser_require (parser, traits_t::open_token_type,
5
←
Calling 'cp_parser_require'→
12
←
Returning from 'cp_parser_require'→
13
←
Returning value, which participates in a condition later→
	      traits_t::required_token_open);
}

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

cp_token * consume_open (cp_parser *parser)
{
  cp_token *tok = cp_lexer_consume_token (parser->lexer);
  gcc_assert (tok->type == traits_t::open_token_type)((void)(!(tok->type == traits_t::open_token_type) ? fancy_abort
 ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 5067, __FUNCTION__), 0 : 0));
  m_open_loc = tok->location;
  return tok;
}

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

cp_token *require_close (cp_parser *parser) const
{
  return cp_parser_require (parser, traits_t::close_token_type,
42
←
Calling 'cp_parser_require'→
49
←
Returning from 'cp_parser_require'→
50
←
Returning pointer, which participates in a condition later→
	      traits_t::required_token_close,
	      m_open_loc);
}

location_t open_location () const { return m_open_loc; }

private:
location_t m_open_loc;
5088};

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

5092struct matching_paren_traits
5093{
static const enum cpp_ttype open_token_type = CPP_OPEN_PAREN;
static const enum required_token required_token_open  = RT_OPEN_PAREN;
static const enum cpp_ttype close_token_type = CPP_CLOSE_PAREN;
static const enum required_token required_token_close = RT_CLOSE_PAREN;
5098};

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

5103typedef token_pair<matching_paren_traits> matching_parens;

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

5107struct matching_brace_traits
5108{
static const enum cpp_ttype open_token_type = CPP_OPEN_BRACE;
static const enum required_token required_token_open = RT_OPEN_BRACE;
static const enum cpp_ttype close_token_type = CPP_CLOSE_BRACE;
static const enum required_token required_token_close = RT_CLOSE_BRACE;
5113};

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

5118typedef token_pair<matching_brace_traits> matching_braces;


5121/* Parse a GNU statement-expression, i.e. ({ stmts }), except for the
 enclosing parentheses.  */

5124static cp_expr
5125cp_parser_statement_expr (cp_parser *parser)
5126{
cp_token_position start = cp_parser_start_tentative_firewall (parser);

/* Consume the '('.  */
location_t start_loc = cp_lexer_peek_token (parser->lexer)->location;
matching_parens parens;
parens.consume_open (parser);
/* Start the statement-expression.  */
tree expr = begin_stmt_expr ();
/* Parse the compound-statement.  */
cp_parser_compound_statement (parser, expr, BCS_NORMAL, false);
/* Finish up.  */
expr = finish_stmt_expr (expr, false);
/* Consume the ')'.  */
location_t finish_loc = cp_lexer_peek_token (parser->lexer)->location;
if (!parens.require_close (parser))
  cp_parser_skip_to_end_of_statement (parser);

cp_parser_end_tentative_firewall (parser, start, expr);
location_t combined_loc = make_location (start_loc, start_loc, finish_loc);
return cp_expr (expr, combined_loc);
5147}

5149/* Expressions [gram.expr] */

5151/* Parse a fold-operator.

  fold-operator:
      -  *  /  %  ^  &  |  =  <  >  <<  >>
    =  -=  *=  /=  %=  ^=  &=  |=  <<=  >>=
    ==  !=  <=  >=  &&  ||  ,  .*  ->*

 This returns the tree code corresponding to the matched operator
 as an int. When the current token matches a compound assignment
 operator, the resulting tree code is the negative value of the
 non-assignment operator. */

5163static int
5164cp_parser_fold_operator (cp_token *token)
5165{
switch (token->type)
  {
  case CPP_PLUS: return PLUS_EXPR;
  case CPP_MINUS: return MINUS_EXPR;
  case CPP_MULT: return MULT_EXPR;
  case CPP_DIV: return TRUNC_DIV_EXPR;
  case CPP_MOD: return TRUNC_MOD_EXPR;
  case CPP_XOR: return BIT_XOR_EXPR;
  case CPP_AND: return BIT_AND_EXPR;
  case CPP_OR: return BIT_IOR_EXPR;
  case CPP_LSHIFT: return LSHIFT_EXPR;
  case CPP_RSHIFT: return RSHIFT_EXPR;

  case CPP_EQ: return -NOP_EXPR;
  case CPP_PLUS_EQ: return -PLUS_EXPR;
  case CPP_MINUS_EQ: return -MINUS_EXPR;
  case CPP_MULT_EQ: return -MULT_EXPR;
  case CPP_DIV_EQ: return -TRUNC_DIV_EXPR;
  case CPP_MOD_EQ: return -TRUNC_MOD_EXPR;
  case CPP_XOR_EQ: return -BIT_XOR_EXPR;
  case CPP_AND_EQ: return -BIT_AND_EXPR;
  case CPP_OR_EQ: return -BIT_IOR_EXPR;
  case CPP_LSHIFT_EQ: return -LSHIFT_EXPR;
  case CPP_RSHIFT_EQ: return -RSHIFT_EXPR;

  case CPP_EQ_EQ: return EQ_EXPR;
  case CPP_NOT_EQ: return NE_EXPR;
  case CPP_LESS: return LT_EXPR;
  case CPP_GREATER: return GT_EXPR;
  case CPP_LESS_EQ: return LE_EXPR;
  case CPP_GREATER_EQ: return GE_EXPR;

  case CPP_AND_AND: return TRUTH_ANDIF_EXPR;
  case CPP_OR_OR: return TRUTH_ORIF_EXPR;

  case CPP_COMMA: return COMPOUND_EXPR;

  case CPP_DOT_STAR: return DOTSTAR_EXPR;
  case CPP_DEREF_STAR: return MEMBER_REF;

  default: return ERROR_MARK;
  }
5208}

5210/* Returns true if CODE indicates a binary expression, which is not allowed in
 the LHS of a fold-expression.  More codes will need to be added to use this
 function in other contexts.  */

5214static bool
5215is_binary_op (tree_code code)
5216{
switch (code)
  {
  case PLUS_EXPR:
  case POINTER_PLUS_EXPR:
  case MINUS_EXPR:
  case MULT_EXPR:
  case TRUNC_DIV_EXPR:
  case TRUNC_MOD_EXPR:
  case BIT_XOR_EXPR:
  case BIT_AND_EXPR:
  case BIT_IOR_EXPR:
  case LSHIFT_EXPR:
  case RSHIFT_EXPR:

  case MODOP_EXPR:

  case EQ_EXPR:
  case NE_EXPR:
  case LE_EXPR:
  case GE_EXPR:
  case LT_EXPR:
  case GT_EXPR:

  case TRUTH_ANDIF_EXPR:
  case TRUTH_ORIF_EXPR:

  case COMPOUND_EXPR:

  case DOTSTAR_EXPR:
  case MEMBER_REF:
    return true;

  default:
    return false;
  }
5252}

5254/* If the next token is a suitable fold operator, consume it and return as
 the function above.  */

5257static int
5258cp_parser_fold_operator (cp_parser *parser)
5259{
cp_token* token = cp_lexer_peek_token (parser->lexer);
int code = cp_parser_fold_operator (token);
if (code != ERROR_MARK)
  cp_lexer_consume_token (parser->lexer);
return code;
5265}

5267/* Parse a fold-expression.

   fold-expression:
     ( ... folding-operator cast-expression)
     ( cast-expression folding-operator ... )
     ( cast-expression folding operator ... folding-operator cast-expression)

 Note that the '(' and ')' are matched in primary expression. */

5276static cp_expr
5277cp_parser_fold_expression (cp_parser *parser, tree expr1)
5278{
cp_id_kind pidk;

// Left fold.
if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
  {
    if (expr1)
return error_mark_nodeglobal_trees[TI_ERROR_MARK];
    cp_lexer_consume_token (parser->lexer);
    int op = cp_parser_fold_operator (parser);
    if (op == ERROR_MARK)
      {
        cp_parser_error (parser, "expected binary operator");
        return error_mark_nodeglobal_trees[TI_ERROR_MARK];
      }

    tree expr = cp_parser_cast_expression (parser, false, false,
			     false, &pidk);
    if (expr == error_mark_nodeglobal_trees[TI_ERROR_MARK])
      return error_mark_nodeglobal_trees[TI_ERROR_MARK];
    return finish_left_unary_fold_expr (expr, op);
  }

const cp_token* token = cp_lexer_peek_token (parser->lexer);
int op = cp_parser_fold_operator (parser);
if (op == ERROR_MARK)
  {
    cp_parser_error (parser, "expected binary operator");
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }

if (cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS))
  {
    cp_parser_error (parser, "expected ...");
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }
cp_lexer_consume_token (parser->lexer);

/* The operands of a fold-expression are cast-expressions, so binary or
   conditional expressions are not allowed.  We check this here to avoid
   tentative parsing.  */
if (EXPR_P (expr1)((tree_code_type[(int) (((enum tree_code) (expr1)->base.code
))]) >= tcc_reference && (tree_code_type[(int) (((
enum tree_code) (expr1)->base.code))]) <= tcc_expression
) && TREE_NO_WARNING (expr1)((expr1)->base.nowarning_flag))
  /* OK, the expression was parenthesized.  */;
else if (is_binary_op (TREE_CODE (expr1)((enum tree_code) (expr1)->base.code)))
  error_at (location_of (expr1),
     "binary expression in operand of fold-expression");
else if (TREE_CODE (expr1)((enum tree_code) (expr1)->base.code) == COND_EXPR
  || (REFERENCE_REF_P (expr1)((((enum tree_code) (expr1)->base.code) == INDIRECT_REF) &&
 ((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 ((expr1), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 5325, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 5325, __FUNCTION__))->typed.type) && (((enum tree_code
) (((contains_struct_check (((*((const_cast<tree*> (tree_operand_check
 (((expr1)), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 5325, __FUNCTION__)))))), (TS_TYPED), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 5325, __FUNCTION__))->typed.type))->base.code) == REFERENCE_TYPE
))
      && TREE_CODE (TREE_OPERAND (expr1, 0))((enum tree_code) ((*((const_cast<tree*> (tree_operand_check
 ((expr1), (0), "/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 5326, __FUNCTION__))))))->base.code) == COND_EXPR))
  error_at (location_of (expr1),
     "conditional expression in operand of fold-expression");

// Right fold.
if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
  return finish_right_unary_fold_expr (expr1, op);

if (cp_lexer_next_token_is_not (parser->lexer, token->type))
  {
    cp_parser_error (parser, "mismatched operator in fold-expression");
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }
cp_lexer_consume_token (parser->lexer);

// Binary left or right fold.
tree expr2 = cp_parser_cast_expression (parser, false, false, false, &pidk);
if (expr2 == error_mark_nodeglobal_trees[TI_ERROR_MARK])
  return error_mark_nodeglobal_trees[TI_ERROR_MARK];
return finish_binary_fold_expr (expr1, expr2, op);
5346}

5348/* Parse a primary-expression.

 primary-expression:
   literal
   this
   ( expression )
   id-expression
   lambda-expression (C++11)

 GNU Extensions:

 primary-expression:
   ( compound-statement )
   __builtin_va_arg ( assignment-expression , type-id )
   __builtin_offsetof ( type-id , offsetof-expression )

 C++ Extensions:
   __has_nothrow_assign ( type-id )
   __has_nothrow_constructor ( type-id )
   __has_nothrow_copy ( type-id )
   __has_trivial_assign ( type-id )
   __has_trivial_constructor ( type-id )
   __has_trivial_copy ( type-id )
   __has_trivial_destructor ( type-id )
   __has_virtual_destructor ( type-id )
   __is_abstract ( type-id )
   __is_base_of ( type-id , type-id )
   __is_class ( type-id )
   __is_empty ( type-id )
   __is_enum ( type-id )
   __is_final ( type-id )
   __is_literal_type ( type-id )
   __is_pod ( type-id )
   __is_polymorphic ( type-id )
   __is_std_layout ( type-id )
   __is_trivial ( type-id )
   __is_union ( type-id )

 Objective-C++ Extension:

 primary-expression:
   objc-expression

 literal:
   __null

 ADDRESS_P is true iff this expression was immediately preceded by
 "&" and therefore might denote a pointer-to-member.  CAST_P is true
 iff this expression is the target of a cast.  TEMPLATE_ARG_P is
 true iff this expression is a template argument.

 Returns a representation of the expression.  Upon return, *IDK
 indicates what kind of id-expression (if any) was present.  */

5402static cp_expr
5403cp_parser_primary_expression (cp_parser *parser,
	      bool address_p,
	      bool cast_p,
	      bool template_arg_p,
	      bool decltype_p,
	      cp_id_kind *idk)
5409{
cp_token *token = NULL__null;

/* Assume the primary expression is not an id-expression.  */
*idk = CP_ID_KIND_NONE;

/* Peek at the next token.  */
token = cp_lexer_peek_token (parser->lexer);
switch ((int) token->type)
  {
    /* literal:
  integer-literal
  character-literal
  floating-literal
  string-literal
  boolean-literal
  pointer-literal
  user-defined-literal  */
  case CPP_CHAR:
  case CPP_CHAR16:
  case CPP_CHAR32:
  case CPP_WCHAR:
  case CPP_UTF8CHAR:
  case CPP_NUMBER:
  case CPP_PREPARSED_EXPR((enum cpp_ttype) (((enum cpp_ttype) (((enum cpp_ttype) (((enum
 cpp_ttype) (CPP_KEYWORD + 1)) + 1)) + 1)) + 1)):
    if (TREE_CODE (token->u.value)((enum tree_code) (token->u.value)->base.code) == USERDEF_LITERAL)
return cp_parser_userdef_numeric_literal (parser);
    token = cp_lexer_consume_token (parser->lexer);
    if (TREE_CODE (token->u.value)((enum tree_code) (token->u.value)->base.code) == FIXED_CST)
{
 error_at (token->location,
    "fixed-point types not supported in C++");
 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
}
    /* Floating-point literals are only allowed in an integral
constant expression if they are cast to an integral or
enumeration type.  */
    if (TREE_CODE (token->u.value)((enum tree_code) (token->u.value)->base.code) == REAL_CST
 && parser->integral_constant_expression_p
 && pedanticglobal_options.x_pedantic)
{
 /* CAST_P will be set even in invalid code like "int(2.7 +
    ...)".   Therefore, we have to check that the next token
    is sure to end the cast.  */
 if (cast_p)
   {
     cp_token *next_token;

     next_token = cp_lexer_peek_token (parser->lexer);
     if (/* The comma at the end of an
     enumerator-definition.  */
  next_token->type != CPP_COMMA
  /* The curly brace at the end of an enum-specifier.  */
  && next_token->type != CPP_CLOSE_BRACE
  /* The end of a statement.  */
  && next_token->type != CPP_SEMICOLON
  /* The end of the cast-expression.  */
  && next_token->type != CPP_CLOSE_PAREN
  /* The end of an array bound.  */
  && next_token->type != CPP_CLOSE_SQUARE
  /* The closing ">" in a template-argument-list.  */
  && (next_token->type != CPP_GREATER
      || parser->greater_than_is_operator_p)
  /* C++0x only: A ">>" treated like two ">" tokens,
                   in a template-argument-list.  */
  && (next_token->type != CPP_RSHIFT
                    || (cxx_dialect == cxx98)
      || parser->greater_than_is_operator_p))
cast_p = false;
   }

 /* If we are within a cast, then the constraint that the
    cast is to an integral or enumeration type will be
    checked at that point.  If we are not within a cast, then
    this code is invalid.  */
 if (!cast_p)
   cp_parser_non_integral_constant_expression (parser, NIC_FLOAT);
}
    return (cp_expr (token->u.value, token->location)
     .maybe_add_location_wrapper ());

  case CPP_CHAR_USERDEF:
  case CPP_CHAR16_USERDEF:
  case CPP_CHAR32_USERDEF:
  case CPP_WCHAR_USERDEF:
  case CPP_UTF8CHAR_USERDEF:
    return cp_parser_userdef_char_literal (parser);

  case CPP_STRING:
  case CPP_STRING16:
  case CPP_STRING32:
  case CPP_WSTRING:
  case CPP_UTF8STRING:
  case CPP_STRING_USERDEF:
  case CPP_STRING16_USERDEF:
  case CPP_STRING32_USERDEF:
  case CPP_WSTRING_USERDEF:
  case CPP_UTF8STRING_USERDEF:
    /* ??? Should wide strings be allowed when parser->translate_strings_p
is false (i.e. in attributes)?  If not, we can kill the third
argument to cp_parser_string_literal.  */
    return (cp_parser_string_literal (parser,
			parser->translate_strings_p,
			true)
     .maybe_add_location_wrapper ());

  case CPP_OPEN_PAREN:
    /* If we see `( { ' then we are looking at the beginning of
a GNU statement-expression.  */
    if (cp_parser_allow_gnu_extensions_p (parser)
 && cp_lexer_nth_token_is (parser->lexer, 2, CPP_OPEN_BRACE))
{
 /* Statement-expressions are not allowed by the standard.  */
 pedwarn (token->location, OPT_Wpedantic,
   "ISO C++ forbids braced-groups within expressions");

 /* And they're not allowed outside of a function-body; you
    cannot, for example, write:

    int i = ({ int j = 3; j + 1; });

    at class or namespace scope.  */
 if (!parser->in_function_body
     || parser->in_template_argument_list_p)
   {
     error_at (token->location,
	"statement-expressions are not allowed outside "
	"functions nor in template-argument lists");
     cp_parser_skip_to_end_of_block_or_statement (parser);
     if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN))
cp_lexer_consume_token (parser->lexer);
     return error_mark_nodeglobal_trees[TI_ERROR_MARK];
   }
 else
   return cp_parser_statement_expr (parser);
}
    /* Otherwise it's a normal parenthesized expression.  */
    {
cp_expr expr;
bool saved_greater_than_is_operator_p;

location_t open_paren_loc = token->location;

/* Consume the `('.  */
matching_parens parens;
parens.consume_open (parser);
/* Within a parenthesized expression, a `>' token is always
  the greater-than operator.  */
saved_greater_than_is_operator_p
 = parser->greater_than_is_operator_p;
parser->greater_than_is_operator_p = true;

if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS))
 /* Left fold expression. */
 expr = NULL_TREE(tree) __null;
else
 /* Parse the parenthesized expression.  */
 expr = cp_parser_expression (parser, idk, cast_p, decltype_p);

token = cp_lexer_peek_token (parser->lexer);
if (token->type == CPP_ELLIPSIS || cp_parser_fold_operator (token))
 {
   expr = cp_parser_fold_expression (parser, expr);
   if (expr != error_mark_nodeglobal_trees[TI_ERROR_MARK]
&& cxx_dialect < cxx17)
     pedwarn (input_location, 0, "fold-expressions only available "
       "with %<-std=c++17%> or %<-std=gnu++17%>");
 }
else
 /* Let the front end know that this expression was
    enclosed in parentheses. This matters in case, for
    example, the expression is of the form `A::B', since
    `&A::B' might be a pointer-to-member, but `&(A::B)' is
    not.  */
 expr = finish_parenthesized_expr (expr);

/* DR 705: Wrapping an unqualified name in parentheses
  suppresses arg-dependent lookup.  We want to pass back
  CP_ID_KIND_QUALIFIED for suppressing vtable lookup
  (c++/37862), but none of the others.  */
if (*idk != CP_ID_KIND_QUALIFIED)
 *idk = CP_ID_KIND_NONE;

/* The `>' token might be the end of a template-id or
  template-parameter-list now.  */
parser->greater_than_is_operator_p
 = saved_greater_than_is_operator_p;

/* Consume the `)'.  */
token = cp_lexer_peek_token (parser->lexer);
location_t close_paren_loc = token->location;
expr.set_range (open_paren_loc, close_paren_loc);
if (!parens.require_close (parser)
   && !cp_parser_uncommitted_to_tentative_parse_p (parser))
 cp_parser_skip_to_end_of_statement (parser);

return expr;
    }

  case CPP_OPEN_SQUARE:
    {
if (c_dialect_objc ()((c_language & clk_objc) != 0))
 {
   /* We might have an Objective-C++ message. */
   cp_parser_parse_tentatively (parser);
   tree msg = cp_parser_objc_message_expression (parser);
   /* If that works out, we're done ... */
   if (cp_parser_parse_definitely (parser))
     return msg;
   /* ... else, fall though to see if it's a lambda.  */
 }
cp_expr lam = cp_parser_lambda_expression (parser);
/* Don't warn about a failed tentative parse.  */
if (cp_parser_error_occurred (parser))
 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
maybe_warn_cpp0x (CPP0X_LAMBDA_EXPR);
return lam;
    }

  case CPP_OBJC_STRING:
    if (c_dialect_objc ()((c_language & clk_objc) != 0))
/* We have an Objective-C++ string literal. */
      return cp_parser_objc_expression (parser);
    cp_parser_error (parser, "expected primary-expression");
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];

  case CPP_KEYWORD:
    switch (token->keyword)
{
 /* These two are the boolean literals.  */
case RID_TRUE:
 cp_lexer_consume_token (parser->lexer);
 return cp_expr (boolean_true_nodeglobal_trees[TI_BOOLEAN_TRUE], token->location);
case RID_FALSE:
 cp_lexer_consume_token (parser->lexer);
 return cp_expr (boolean_false_nodeglobal_trees[TI_BOOLEAN_FALSE], token->location);

 /* The `__null' literal.  */
case RID_NULL:
 cp_lexer_consume_token (parser->lexer);
 return cp_expr (null_nodec_global_trees[CTI_NULL], token->location);

 /* The `nullptr' literal.  */
case RID_NULLPTR:
 cp_lexer_consume_token (parser->lexer);
 return cp_expr (nullptr_nodecp_global_trees[CPTI_NULLPTR], token->location);

 /* Recognize the `this' keyword.  */
case RID_THIS:
 cp_lexer_consume_token (parser->lexer);
 if (parser->local_variables_forbidden_p & THIS_FORBIDDEN(1 << 1))
   {
     error_at (token->location,
	"%<this%> may not be used in this context");
     return error_mark_nodeglobal_trees[TI_ERROR_MARK];
   }
 /* Pointers cannot appear in constant-expressions.  */
 if (cp_parser_non_integral_constant_expression (parser, NIC_THIS))
   return error_mark_nodeglobal_trees[TI_ERROR_MARK];
 return cp_expr (finish_this_expr (), token->location);

 /* The `operator' keyword can be the beginning of an
    id-expression.  */
case RID_OPERATOR:
 goto id_expression;

case RID_FUNCTION_NAME:
case RID_PRETTY_FUNCTION_NAME:
case RID_C99_FUNCTION_NAME:
 {
   non_integral_constant name;

   /* The symbols __FUNCTION__, __PRETTY_FUNCTION__, and
      __func__ are the names of variables -- but they are
      treated specially.  Therefore, they are handled here,
      rather than relying on the generic id-expression logic
      below.  Grammatically, these names are id-expressions.

      Consume the token.  */
   token = cp_lexer_consume_token (parser->lexer);

   switch (token->keyword)
     {
     case RID_FUNCTION_NAME:
name = NIC_FUNC_NAME;
break;
     case RID_PRETTY_FUNCTION_NAME:
name = NIC_PRETTY_FUNC;
break;
     case RID_C99_FUNCTION_NAME:
name = NIC_C99_FUNC;
break;
     default:
gcc_unreachable ()(fancy_abort ("/home/marxin/BIG/buildbot/buildworker/marxinbox-gcc-clang-static-analyzer/build/gcc/cp/parser.c"
, 5702, __FUNCTION__));
     }

   if (cp_parser_non_integral_constant_expression (parser, name))
     return error_mark_nodeglobal_trees[TI_ERROR_MARK];

   /* Look up the name.  */
   return finish_fname (token->u.value);
 }

case RID_VA_ARG:
 {
   tree expression;
   tree type;
   location_t type_location;
   location_t start_loc
     = cp_lexer_peek_token (parser->lexer)->location;
   /* The `__builtin_va_arg' construct is used to handle
      `va_arg'.  Consume the `__builtin_va_arg' token.  */
   cp_lexer_consume_token (parser->lexer);
   /* Look for the opening `('.  */
   matching_parens parens;
   parens.require_open (parser);
   /* Now, parse the assignment-expression.  */
   expression = cp_parser_assignment_expression (parser);
   /* Look for the `,'.  */
   cp_parser_require (parser, CPP_COMMA, RT_COMMA);
   type_location = cp_lexer_peek_token (parser->lexer)->location;
   /* Parse the type-id.  */
   {
     type_id_in_expr_sentinel s (parser);
     type = cp_parser_type_id (parser);
   }
   /* Look for the closing `)'.  */
   location_t finish_loc
     = cp_lexer_peek_token (parser->lexer)->location;
   parens.require_close (parser);
   /* Using `va_arg' in a constant-expression is not
      allowed.  */
   if (cp_parser_non_integral_constant_expression (parser,
					    NIC_VA_ARG))
     return error_mark_nodeglobal_trees[TI_ERROR_MARK];
   /* Construct a location of the form:
 __builtin_va_arg (v, int)
 ~~~~~~~~~~~~~~~~~~~~~^~~~
      with the caret at the type, ranging from the start of the
      "__builtin_va_arg" token to the close paren.  */
   location_t combined_loc
     = make_location (type_location, start_loc, finish_loc);
   return build_x_va_arg (combined_loc, expression, type);
 }

case RID_OFFSETOF:
 return cp_parser_builtin_offsetof (parser);

case RID_HAS_NOTHROW_ASSIGN:
case RID_HAS_NOTHROW_CONSTRUCTOR:
case RID_HAS_NOTHROW_COPY:
case RID_HAS_TRIVIAL_ASSIGN:
case RID_HAS_TRIVIAL_CONSTRUCTOR:
case RID_HAS_TRIVIAL_COPY:
case RID_HAS_TRIVIAL_DESTRUCTOR:
case RID_HAS_UNIQUE_OBJ_REPRESENTATIONS:
case RID_HAS_VIRTUAL_DESTRUCTOR:
case RID_IS_ABSTRACT:
case RID_IS_AGGREGATE:
case RID_IS_BASE_OF:
case RID_IS_CLASS:
case RID_IS_EMPTY:
case RID_IS_ENUM:
case RID_IS_FINAL:
case RID_IS_LITERAL_TYPE:
case RID_IS_POD:
case RID_IS_POLYMORPHIC:
case RID_IS_SAME_AS:
case RID_IS_STD_LAYOUT:
case RID_IS_TRIVIAL:
case RID_IS_TRIVIALLY_ASSIGNABLE:
case RID_IS_TRIVIALLY_CONSTRUCTIBLE:
case RID_IS_TRIVIALLY_COPYABLE:
case RID_IS_UNION:
case RID_IS_ASSIGNABLE:
case RID_IS_CONSTRUCTIBLE:
case RID_IS_NOTHROW_ASSIGNABLE:
case RID_IS_NOTHROW_CONSTRUCTIBLE:
 return cp_parser_trait_expr (parser, token->keyword);

// C++ concepts
case RID_REQUIRES:
 return cp_parser_requires_expression (parser);

/* Objective-C++ expressions.  */
case RID_AT_ENCODE:
case RID_AT_PROTOCOL:
case RID_AT_SELECTOR:
 return cp_parser_objc_expression (parser);

case RID_TEMPLATE:
 if (parser->in_function_body
     && (cp_lexer_peek_nth_token (parser->lexer, 2)->type
     	  == CPP_LESS))
   {
     error_at (token->location,
	"a template declaration cannot appear at block scope");
     cp_parser_skip_to_end_of_block_or_statement (parser);
     return error_mark_nodeglobal_trees[TI_ERROR_MARK];
   }
 /* FALLTHRU */
default:
 cp_parser_error (parser, "expected primary-expression");
 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
}

    /* An id-expression can start with either an identifier, a
`::' as the beginning of a qualified-id, or the "operator"
keyword.  */
  case CPP_NAME:
  case CPP_SCOPE:
  case CPP_TEMPLATE_ID((enum cpp_ttype) (CPP_KEYWORD + 1)):
  case CPP_NESTED_NAME_SPECIFIER((enum cpp_ttype) (((enum cpp_ttype) (CPP_KEYWORD + 1)) + 1)):
    {
    id_expression:
cp_expr id_expression;
cp_expr decl;
const char *error_msg;
bool template_p;
bool done;
cp_token *id_expr_token;

/* Parse the id-expression.  */
id_expression
 = cp_parser_id_expression (parser,
		     /*template_keyword_p=*/false,
		     /*check_dependency_p=*/true,
		     &template_p,
		     /*declarator_p=*/false,
		     /*optional_p=*/false);
if (id_expression == error_mark_nodeglobal_trees[TI_ERROR_MARK])
 return error_mark_nodeglobal_trees[TI_ERROR_MARK];
id_expr_token = token;
token = cp_lexer_peek_token (parser->lexer);
done = (token->type != CPP_OPEN_SQUARE
&& token->type != CPP_OPEN_PAREN
&& token->type != CPP_DOT
&& token->type != CPP_DEREF
&& token->type != CPP_PLUS_PLUS
&& token->type != CPP_MINUS_MINUS);
/* If we have a template-id, then no further lookup is
  required.  If the template-id was for a template-class, we
  will sometimes have a TYPE_DECL at this point.  */
if (TREE_CODE (id_expression)((enum tree_code) (id_expression)->base.code) == TEMPLATE_ID_EXPR
 || TREE_CODE (id_expression)((enum tree_code) (id_expression)->base.code) == TYPE_DECL)
 decl = id_expression;
/* Look up the name.  */
else
 {
   tree ambiguous_decls;

   /* If we already know that this lookup is ambiguous, then
      we've already issued an error message; there's no reason
      to check again.  */
   if (id_expr_token->type == CPP_NAME
&& id_expr_token->error_reported)
     {
cp_parser_simulate_error (parser);
return error_mark_nodeglobal_trees[TI_ERROR_MARK];
     }

   decl = cp_parser_lookup_name (parser, id_expression,
			  none_type,
			  template_p,
			  /*is_namespace=*/false,
			  /*check_dependency=*/true,
			  &ambiguous_decls,
			  id_expression.get_location ());
   /* If the lookup was ambiguous, an error will already have
      been issued.  */
   if (ambiguous_decls)
     return error_mark_nodeglobal_trees[TI_ERROR_MARK];

   /* In Objective-C++, we may have an Objective-C 2.0
      dot-syntax for classes here.  */
   if (c_dialect_objc ()((c_language & clk_objc) != 0)
&& cp_lexer_peek_token (parser->lexer)->type == CPP_DOT
&& TREE_CODE (decl)((enum tree_code) (decl)->base.code) == TYPE_DECL
&& objc_is_class_name (decl))
     {
tree component;
cp_lexer_consume_token (parser->lexer);
component = cp_parser_identifier (parser);
if (component == error_mark_nodeglobal_trees[TI_ERROR_MARK])
  return error_mark_nodeglobal_trees[TI_ERROR_MARK];

tree result = objc_build_class_component_ref (id_expression,
					      component);
/* Build a location of the form:
     expr.component
     ~~~~~^~~~~~~~~
   with caret at the start of the component name (at
   input_location), ranging from the start of the id_expression
   to the end of the component name.  */
location_t combined_loc
  = make_location (input_location, id_expression.get_start (),
		   get_finish (input_location));
protected_set_expr_location (result, combined_loc);
return result;
     }

   /* In Objective-C++, an instance variable (ivar) may be preferred
      to whatever cp_parser_lookup_name() found.
      Call objc_lookup_ivar.  To avoid exposing cp_expr to the
      rest of c-family, we have to do a little extra work to preserve
      any location information in cp_expr "decl".  Given that
      objc_lookup_ivar is implemented in "c-family" and "objc", we
      have a trip through the pure "tree" type, rather than cp_expr.
      Naively copying it back to "decl" would implicitly give the
      new cp_expr value an UNKNOWN_LOCATION for nodes that don't
      store an EXPR_LOCATION.  Hence we only update "decl" (and
      hence its location_t) if we get back a different tree node.  */
   tree decl_tree = objc_lookup_ivar (decl.get_value (),
			       id_expression);
   if (decl_tree != decl.get_value ())
     decl = cp_expr (decl_tree);

   /* If name lookup gives us a SCOPE_REF, then the
      qualifying scope was dependent.  */
   if (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == SCOPE_REF)
     {
/* At this point, we do not know if DECL is a valid
   integral constant expression.  We assume that it is
   in fact such an expression, so that code like:

      template <int N> struct A {
	int a[B<N>::i];
      };

   is accepted.  At template-instantiation time, we
   will check that B<N>::i is actually a constant.  */
return decl;
     }
   /* Check to see if DECL is a local variable in a context
      where that is forbidden.  */
   if ((parser->local_variables_forbidden_p & LOCAL_VARS_FORBIDDEN(1 << 0))
&& local_variable_p (decl))
     {
const char *msg
  = (TREE_CODE (decl)((enum tree_code) (decl)->base.code) == PARM_DECL
     ? _("parameter %qD may not appear in this context")gettext ("parameter %qD may not appear in this context")
     : _("local variable %qD may not appear in this context")gettext ("local variable %qD may not appear in this context"));
error_at (id_expression.get_location (), msg,
	  decl.get_value ());
return error_mark_nodeglobal_trees[TI_ERROR_MARK];
     }
 }

decl = (finish_id_expression
(id_expression, decl, parser->scope,
 idk,
 parser->integral_constant_expression_p,
 parser->allow_non_integral_constant_expression_p,
 &parser->non_integral_constant_expression_p,
 template_p, done, address_p,
 template_arg_p,
 &error_msg,
 id_expression.get_location ()));
if (error_msg)
 cp_parser_error (parser, error_msg);
/* Build a location for an id-expression of the form:
    ::ns::id
           ~~~~~~^~
 or:
    id
    ^~
  i.e. from the start of the first token to the end of the final
  token, with the caret at the start of the unqualified-id.  */
location_t caret_loc = get_pure_location (id_expression.get_location ());
location_t start_loc = get_start (id_expr_token->location);
location_t finish_loc = get_finish (id_expression.get_location ());
location_t combined_loc
 = make_location (caret_loc, start_loc, finish_loc);

decl.set_location (combined_loc);
return decl;
    }

    /* Anything else is an error.  */
  default:
    cp_parser_error (parser, "expected primary-expression");
    return error_mark_nodeglobal_trees[TI_ERROR_MARK];
  }
5992}

5994static inline cp_expr
5995cp_parser_primary_expression (cp_parser *parser,
	      bool address_p,
	      bool cast_p,
	      bool template_arg_p,
	      cp_id_kind *idk)
6000{
return cp_parser_primary_expression (parser, address_p, cast_p, template_arg_p,
		       /*decltype*/false, idk);
6003}

6005/* Parse an id-expression.

 id-expression:
   unqualified-id
   qualified-id

 qualified-id:
   :: [opt] nested-name-specifier template [opt] unqualified-id
   :: identifier
   :: operator-function-id
   :: template-id

 Return a representation of the unqualified portion of the
 identifier.  Sets PARSER->SCOPE to the qualifying scope if there is
 a `::' or nested-name-specifier.

 Often, if the id-expression was a qualified-id, the caller will
 want to make a SCOPE_REF to represent the qualified-id.  This
 function does not do this in order to avoid wastefully creating
 SCOPE_REFs when they are not required.

 If TEMPLATE_KEYWORD_P is true, then we have just seen the
 `template' keyword.

 If CHECK_DEPENDENCY_P is false, then names are looked up inside
 uninstantiated templates.

 If *TEMPLATE_P is non-NULL, it is set to true iff the
 `template' keyword is used to explicitly indicate that the entity
 named is a template.

 If DECLARATOR_P is true, the id-expression is appearing as part of
 a declarator, rather than as part of an expression.  */

6039static cp_expr
6040cp_parser_id_expression (cp_parser *parser,
	 bool template_keyword_p,
	 bool check_dependency_p,
	 bool *template_p,
	 bool declarator_p,
	 bool optional_p)
6046{
bool global_scope_p;
bool nested_name_specifier_p;

/* Assume the `template' keyword was not used.  */
if (template_p)
  *template_p = template_keyword_p;

/* Look for the optional `::' operator.  */
global_scope_p
  = (!template_keyword_p
     && (cp_parser_global_scope_opt (parser,
		       /*current_scope_valid_p=*/false)
  != NULL_TREE(tree) __null));

/* Look for the optional nested-name-specifier.  */
nested_name_specifier_p
  = (cp_parser_nested_name_specifier_opt (parser,
			    /*typename_keyword_p=*/false,
			    check_dependency_p,
			    /*type_p=*/false,
			    declarator_p,
			    template_keyword_p)
     != NULL_TREE(tree) __null);

/* If there is a nested-name-specifier, then we are looking at
   the first qualified-id production.  */
if (nested_name_specifier_p)
  {
    tree saved_scope;
    tree saved_object_scope;
    tree saved_qualifying_scope;
    cp_expr unqualified_id;