diff options
Diffstat (limited to 'gcc-4.2.1-5666.3/gcc/cp/parser.c')
| -rw-r--r-- | gcc-4.2.1-5666.3/gcc/cp/parser.c | 23464 |
1 files changed, 0 insertions, 23464 deletions
diff --git a/gcc-4.2.1-5666.3/gcc/cp/parser.c b/gcc-4.2.1-5666.3/gcc/cp/parser.c deleted file mode 100644 index 2b0199b39..000000000 --- a/gcc-4.2.1-5666.3/gcc/cp/parser.c +++ /dev/null @@ -1,23464 +0,0 @@ -/* C++ Parser. - Copyright (C) 2000, 2001, 2002, 2003, 2004, - 2005 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 2, 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. - - You should have received a copy of the GNU General Public License - along with GCC; see the file COPYING. If not, write to the Free - Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA - 02110-1301, USA. */ - -#include "config.h" -#include "system.h" -#include "coretypes.h" -#include "tm.h" -#include "dyn-string.h" -#include "varray.h" -#include "cpplib.h" -#include "tree.h" -#include "cp-tree.h" -#include "c-pragma.h" -#include "decl.h" -#include "flags.h" -#include "diagnostic.h" -#include "toplev.h" -#include "output.h" -#include "target.h" -/* APPLE LOCAL 4133801 */ -#include "debug.h" -#include "cgraph.h" -#include "c-common.h" -/* APPLE LOCAL pascal strings */ -#include "../../libcpp/internal.h" -/* APPLE LOCAL C* language */ -#include "tree-iterator.h" - - -/* The lexer. */ - -/* The cp_lexer_* routines mediate between the lexer proper (in libcpp - and c-lex.c) and the C++ parser. */ - -/* A token's value and its associated deferred access checks and - qualifying scope. */ - -struct tree_check GTY(()) -{ - /* The value associated with the token. */ - tree value; - /* The checks that have been associated with value. */ - VEC (deferred_access_check, gc)* checks; - /* The token's qualifying scope (used when it is a - CPP_NESTED_NAME_SPECIFIER). */ - tree qualifying_scope; -}; - -/* A C++ token. */ - -typedef struct cp_token GTY (()) -{ - /* The kind of token. */ - ENUM_BITFIELD (cpp_ttype) type : 8; - /* If this token is a keyword, this value indicates which keyword. - Otherwise, this value is RID_MAX. */ - ENUM_BITFIELD (rid) keyword : 8; - /* Token flags. */ - unsigned char flags; - /* Identifier for the pragma. */ - ENUM_BITFIELD (pragma_kind) pragma_kind : 6; - /* True if this token is from a system header. */ - BOOL_BITFIELD in_system_header : 1; - /* True if this token is from a context where it is implicitly extern "C" */ - BOOL_BITFIELD implicit_extern_c : 1; - /* True for a CPP_NAME token that is not a keyword (i.e., for which - KEYWORD is RID_MAX) iff this name was looked up and found to be - ambiguous. An error has already been reported. */ - BOOL_BITFIELD ambiguous_p : 1; - /* The input file stack index at which this token was found. */ - unsigned input_file_stack_index : INPUT_FILE_STACK_BITS; - /* The value associated with this token, if any. */ - union cp_token_value { - /* Used for CPP_NESTED_NAME_SPECIFIER and CPP_TEMPLATE_ID. */ - struct tree_check* GTY((tag ("1"))) tree_check_value; - /* Use for all other tokens. */ - tree GTY((tag ("0"))) value; - } GTY((desc ("(%1.type == CPP_TEMPLATE_ID) || (%1.type == CPP_NESTED_NAME_SPECIFIER)"))) u; - /* The location at which this token was found. */ - location_t location; -} cp_token; - -/* We use a stack of token pointer for saving token sets. */ -typedef struct cp_token *cp_token_position; -DEF_VEC_P (cp_token_position); -DEF_VEC_ALLOC_P (cp_token_position,heap); - -static const cp_token eof_token = -{ - CPP_EOF, RID_MAX, 0, PRAGMA_NONE, 0, 0, false, 0, { NULL }, -#if USE_MAPPED_LOCATION - 0 -#else - {0, 0} -#endif -}; - -/* The cp_lexer structure represents the C++ lexer. It is responsible - for managing the token stream from the preprocessor and supplying - it to the parser. Tokens are never added to the cp_lexer after - it is created. */ - -typedef struct cp_lexer GTY (()) -{ - /* The memory allocated for the buffer. NULL if this lexer does not - own the token buffer. */ - cp_token * GTY ((length ("%h.buffer_length"))) buffer; - /* If the lexer owns the buffer, this is the number of tokens in the - buffer. */ - size_t buffer_length; - - /* A pointer just past the last available token. The tokens - in this lexer are [buffer, last_token). */ - cp_token_position GTY ((skip)) last_token; - - /* The next available token. If NEXT_TOKEN is &eof_token, then there are - no more available tokens. */ - cp_token_position GTY ((skip)) next_token; - - /* A stack indicating positions at which cp_lexer_save_tokens was - called. The top entry is the most recent position at which we - began saving tokens. If the stack is non-empty, we are saving - tokens. */ - VEC(cp_token_position,heap) *GTY ((skip)) saved_tokens; - - /* The next lexer in a linked list of lexers. */ - struct cp_lexer *next; - - /* True if we should output debugging information. */ - bool debugging_p; - - /* True if we're in the context of parsing a pragma, and should not - increment past the end-of-line marker. */ - bool in_pragma; -} cp_lexer; - -/* cp_token_cache is a range of tokens. There is no need to represent - allocate heap memory for it, since tokens are never removed from the - lexer's array. There is also no need for the GC to walk through - a cp_token_cache, since everything in here is referenced through - a lexer. */ - -typedef struct cp_token_cache GTY(()) -{ - /* The beginning of the token range. */ - cp_token * GTY((skip)) first; - - /* Points immediately after the last token in the range. */ - cp_token * GTY ((skip)) last; -} cp_token_cache; - -/* APPLE LOCAL begin C* language */ -/* APPLE LOCAL radar 5130983 */ -int lvalue_or_else (tree*, enum lvalue_use); -static void objc_finish_foreach_stmt (tree); -/* APPLE LOCAL end C* language */ -/* Prototypes. */ - -static cp_lexer *cp_lexer_new_main - (void); -static cp_lexer *cp_lexer_new_from_tokens - (cp_token_cache *tokens); -static void cp_lexer_destroy - (cp_lexer *); -static int cp_lexer_saving_tokens - (const cp_lexer *); -static cp_token_position cp_lexer_token_position - (cp_lexer *, bool); -static cp_token *cp_lexer_token_at - (cp_lexer *, cp_token_position); -static void cp_lexer_get_preprocessor_token - (cp_lexer *, cp_token *); -static inline cp_token *cp_lexer_peek_token - (cp_lexer *); -static cp_token *cp_lexer_peek_nth_token - (cp_lexer *, size_t); -static inline bool cp_lexer_next_token_is - (cp_lexer *, enum cpp_ttype); -static bool cp_lexer_next_token_is_not - (cp_lexer *, enum cpp_ttype); -static bool cp_lexer_next_token_is_keyword - (cp_lexer *, enum rid); -static cp_token *cp_lexer_consume_token - (cp_lexer *); -static void cp_lexer_purge_token - (cp_lexer *); -static void cp_lexer_purge_tokens_after - (cp_lexer *, cp_token_position); -static void cp_lexer_save_tokens - (cp_lexer *); -static void cp_lexer_commit_tokens - (cp_lexer *); -static void cp_lexer_rollback_tokens - (cp_lexer *); -#ifdef ENABLE_CHECKING -static void cp_lexer_print_token - (FILE *, cp_token *); -static inline bool cp_lexer_debugging_p - (cp_lexer *); -static void cp_lexer_start_debugging - (cp_lexer *) ATTRIBUTE_UNUSED; -static void cp_lexer_stop_debugging - (cp_lexer *) ATTRIBUTE_UNUSED; -#else -/* If we define cp_lexer_debug_stream to NULL it will provoke warnings - about passing NULL to functions that require non-NULL arguments - (fputs, fprintf). It will never be used, so all we need is a value - of the right type that's guaranteed not to be NULL. */ -#define cp_lexer_debug_stream stdout -#define cp_lexer_print_token(str, tok) (void) 0 -#define cp_lexer_debugging_p(lexer) 0 -#endif /* ENABLE_CHECKING */ - -static cp_token_cache *cp_token_cache_new - (cp_token *, cp_token *); - -static void cp_parser_initial_pragma - (cp_token *); - -/* Manifest constants. */ -#define CP_LEXER_BUFFER_SIZE ((256 * 1024) / sizeof (cp_token)) -#define CP_SAVED_TOKEN_STACK 5 - -/* A token type for keywords, as opposed to ordinary identifiers. */ -#define CPP_KEYWORD ((enum cpp_ttype) (N_TTYPES + 1)) - -/* A token type for template-ids. If a template-id is processed while - parsing tentatively, it is replaced with a CPP_TEMPLATE_ID token; - the value of the CPP_TEMPLATE_ID is whatever was returned by - cp_parser_template_id. */ -#define CPP_TEMPLATE_ID ((enum cpp_ttype) (CPP_KEYWORD + 1)) - -/* A token type for nested-name-specifiers. If a - nested-name-specifier is processed while parsing tentatively, it is - replaced with a CPP_NESTED_NAME_SPECIFIER token; the value of the - CPP_NESTED_NAME_SPECIFIER is whatever was returned by - cp_parser_nested_name_specifier_opt. */ -#define CPP_NESTED_NAME_SPECIFIER ((enum cpp_ttype) (CPP_TEMPLATE_ID + 1)) - -/* A token type for tokens that are not tokens at all; these are used - to represent slots in the array where there used to be a token - that has now been deleted. */ -#define CPP_PURGED ((enum cpp_ttype) (CPP_NESTED_NAME_SPECIFIER + 1)) - -/* The number of token types, including C++-specific ones. */ -#define N_CP_TTYPES ((int) (CPP_PURGED + 1)) - -/* Variables. */ - -#ifdef ENABLE_CHECKING -/* The stream to which debugging output should be written. */ -static FILE *cp_lexer_debug_stream; -#endif /* ENABLE_CHECKING */ - -/* Create a new main C++ lexer, the lexer that gets tokens from the - preprocessor. */ - -static cp_lexer * -cp_lexer_new_main (void) -{ - cp_token first_token; - cp_lexer *lexer; - cp_token *pos; - size_t alloc; - size_t space; - cp_token *buffer; - /* APPLE LOCAL begin 4137741 */ - - /* Tell cpplib we want CPP_BINCL and CPP_EINCL tokens. */ - cpp_get_options (parse_in)->defer_file_change_debug_hooks = true; - /* APPLE LOCAL end 4137741 */ - - /* 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_parser_initial_pragma (&first_token); - - /* APPLE LOCAL begin 4137741 */ - while (first_token.type == CPP_BINCL - || first_token.type == CPP_EINCL) - { - if (first_token.type == CPP_BINCL) - (*debug_hooks->start_source_file) (TREE_INT_CST_LOW (first_token.u.value), - first_token.location.file); - else - (*debug_hooks->end_source_file) (TREE_INT_CST_LOW (first_token.u.value)); - cp_lexer_get_preprocessor_token (NULL, &first_token); - } - /* APPLE LOCAL end 4137741 */ - - /* Tell c_lex_with_flags not to merge string constants. */ - c_lex_return_raw_strings = true; - - c_common_no_more_pch (); - - /* Allocate the memory. */ - lexer = GGC_CNEW (cp_lexer); - -#ifdef ENABLE_CHECKING - /* Initially we are not debugging. */ - lexer->debugging_p = false; -#endif /* ENABLE_CHECKING */ - lexer->saved_tokens = VEC_alloc (cp_token_position, heap, - CP_SAVED_TOKEN_STACK); - - /* Create the buffer. */ - alloc = CP_LEXER_BUFFER_SIZE; - buffer = GGC_NEWVEC (cp_token, alloc); - - /* Put the first token in the buffer. */ - space = alloc; - pos = buffer; - *pos = first_token; - - /* Get the remaining tokens from the preprocessor. */ - while (pos->type != CPP_EOF) - { - pos++; - if (!--space) - { - space = alloc; - alloc *= 2; - buffer = GGC_RESIZEVEC (cp_token, buffer, alloc); - pos = buffer + space; - } - cp_lexer_get_preprocessor_token (lexer, pos); - } - lexer->buffer = buffer; - lexer->buffer_length = alloc - space; - lexer->last_token = pos; - lexer->next_token = lexer->buffer_length ? buffer : (cp_token *)&eof_token; - - /* Subsequent preprocessor diagnostics should use compiler - diagnostic functions to get the compiler source location. */ - cpp_get_options (parse_in)->client_diagnostic = true; - cpp_get_callbacks (parse_in)->error = cp_cpp_error; - - gcc_assert (lexer->next_token->type != CPP_PURGED); - return lexer; -} - -/* 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. */ - -static cp_lexer * -cp_lexer_new_from_tokens (cp_token_cache *cache) -{ - cp_token *first = cache->first; - cp_token *last = cache->last; - cp_lexer *lexer = GGC_CNEW (cp_lexer); - - /* We do not own the buffer. */ - lexer->buffer = NULL; - lexer->buffer_length = 0; - lexer->next_token = first == last ? (cp_token *)&eof_token : first; - lexer->last_token = last; - - lexer->saved_tokens = VEC_alloc (cp_token_position, heap, - CP_SAVED_TOKEN_STACK); - -#ifdef ENABLE_CHECKING - /* Initially we are not debugging. */ - lexer->debugging_p = false; -#endif - - gcc_assert (lexer->next_token->type != CPP_PURGED); - return lexer; -} - -/* Frees all resources associated with LEXER. */ - -static void -cp_lexer_destroy (cp_lexer *lexer) -{ - if (lexer->buffer) - ggc_free (lexer->buffer); - VEC_free (cp_token_position, heap, lexer->saved_tokens); - ggc_free (lexer); -} - -/* Returns nonzero if debugging information should be output. */ - -#ifdef ENABLE_CHECKING - -static inline bool -cp_lexer_debugging_p (cp_lexer *lexer) -{ - return lexer->debugging_p; -} - -#endif /* ENABLE_CHECKING */ - -static inline cp_token_position -cp_lexer_token_position (cp_lexer *lexer, bool previous_p) -{ - gcc_assert (!previous_p || lexer->next_token != &eof_token); - - return lexer->next_token - previous_p; -} - -static inline cp_token * -cp_lexer_token_at (cp_lexer *lexer ATTRIBUTE_UNUSED, cp_token_position pos) -{ - return pos; -} - -/* nonzero if we are presently saving tokens. */ - -static inline int -cp_lexer_saving_tokens (const cp_lexer* lexer) -{ - return VEC_length (cp_token_position, lexer->saved_tokens) != 0; -} - -/* Store the next token from the preprocessor in *TOKEN. Return true - if we reach EOF. */ - -static void -cp_lexer_get_preprocessor_token (cp_lexer *lexer ATTRIBUTE_UNUSED , - cp_token *token) -{ - static int is_extern_c = 0; - - /* Get a new token from the preprocessor. */ - token->type - /* APPLE LOCAL CW asm blocks C++ comments 6338079 */ - = c_lex_with_flags (&token->u.value, &token->location, &token->flags, 1); - token->input_file_stack_index = input_file_stack_tick; - token->keyword = RID_MAX; - token->pragma_kind = PRAGMA_NONE; - token->in_system_header = in_system_header; - - /* 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 (C_IS_RESERVED_WORD (token->u.value)) - { - /* Mark this token as a keyword. */ - token->type = CPP_KEYWORD; - /* Record which keyword. */ - token->keyword = C_RID_CODE (token->u.value); - /* Update the value. Some keywords are mapped to particular - entities, rather than simply having the value of the - corresponding IDENTIFIER_NODE. For example, `__const' is - mapped to `const'. */ - token->u.value = ridpointers[token->keyword]; - } - else - { - token->ambiguous_p = false; - token->keyword = RID_MAX; - } - } - /* Handle Objective-C++ keywords. */ - else if (token->type == CPP_AT_NAME) - { - token->type = CPP_KEYWORD; - switch (C_RID_CODE (token->u.value)) - { - /* Map 'class' to '@class', 'private' to '@private', etc. */ - case RID_CLASS: token->keyword = RID_AT_CLASS; break; - /* APPLE LOCAL radar 4564694 */ - case RID_AT_PACKAGE: token->keyword = RID_AT_PACKAGE; 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; - default: token->keyword = C_RID_CODE (token->u.value); - } - } - else if (token->type == CPP_PRAGMA) - { - /* We smuggled the cpp_token->u.pragma value in an INTEGER_CST. */ - token->pragma_kind = TREE_INT_CST_LOW (token->u.value); - token->u.value = NULL_TREE; - } -} - -/* Update the globals input_location and in_system_header and the - input file stack from TOKEN. */ -static inline void -cp_lexer_set_source_position_from_token (cp_token *token) -{ - if (token->type != CPP_EOF) - { - input_location = token->location; - in_system_header = token->in_system_header; - restore_input_file_stack (token->input_file_stack_index); - } -} -/* APPLE LOCAL begin 4137741 */ -/* Consume begin and end file marker tokens. */ -static inline void -cp_lexer_consume_bincl_eincl_token (cp_lexer *lexer) -{ - while (lexer->next_token->type == CPP_BINCL - || lexer->next_token->type == CPP_EINCL) - { - if (lexer->next_token->type == CPP_BINCL) - (*debug_hooks->start_source_file) (TREE_INT_CST_LOW (lexer->next_token->u.value), - lexer->next_token->location.file); - else if (lexer->next_token->type == CPP_EINCL) - (*debug_hooks->end_source_file) (TREE_INT_CST_LOW (lexer->next_token->u.value)); - cp_lexer_purge_token (lexer); - } -} -/* APPLE LOCAL end 4137741 */ - -/* Return a pointer to the next token in the token stream, but do not - consume it. */ - -static inline cp_token * -cp_lexer_peek_token (cp_lexer *lexer) -{ - /* APPLE LOCAL begin CW asm blocks */ - top: - if (flag_ms_asms) - if (lexer->next_token->type == CPP_NUMBER - && lexer->next_token->u.value == error_mark_node - && (lexer->next_token->flags & ERROR_DEFERRED)) - { - cp_lexer_set_source_position_from_token (lexer->next_token); - - /* This was previously deferred. */ - lexer->next_token->flags ^= ERROR_DEFERRED; - error ("invalid suffix on integer constant"); - } - if (!inside_iasm_block) - { - if (lexer->next_token->type == CPP_HASH) - { - cp_lexer_consume_token (lexer); - error ("stray %qs in program", "#"); - goto top; - } - else if (lexer->next_token->type == CPP_PASTE) - { - cp_lexer_consume_token (lexer); - error ("stray %qs in program", "##"); - goto top; - } - else if (lexer->next_token->type == CPP_OTHER) - { - tree value = lexer->next_token->u.value; - int c; - c = TREE_INT_CST_LOW (value); - cp_lexer_consume_token (lexer); - if (c == '"' || c == '\'') - error ("missing terminating %c character", (int) c); - else if (ISGRAPH (c)) - error ("stray %qc in program", (int) c); - else - error ("stray %<\\%o%> in program", (int) c); - goto top; - } - } - /* APPLE LOCAL end CW asm blocks */ - /* APPLE LOCAL 4137741 */ - cp_lexer_consume_bincl_eincl_token (lexer); - 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; -} - -/* Return true if the next token has the indicated TYPE. */ - -static inline bool -cp_lexer_next_token_is (cp_lexer* lexer, enum cpp_ttype type) -{ - return cp_lexer_peek_token (lexer)->type == type; -} - -/* Return true if the next token does not have the indicated TYPE. */ - -static inline bool -cp_lexer_next_token_is_not (cp_lexer* lexer, enum cpp_ttype type) -{ - return !cp_lexer_next_token_is (lexer, type); -} - -/* Return true if the next token is the indicated KEYWORD. */ - -static inline bool -cp_lexer_next_token_is_keyword (cp_lexer* lexer, enum rid keyword) -{ - return cp_lexer_peek_token (lexer)->keyword == keyword; -} - -/* Return true if the next token is a keyword for a decl-specifier. */ - -static bool -cp_lexer_next_token_is_decl_specifier_keyword (cp_lexer *lexer) -{ - cp_token *token; - - token = cp_lexer_peek_token (lexer); - switch (token->keyword) - { - /* Storage classes. */ - case RID_AUTO: - 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_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: - return true; - - default: - return false; - } -} - -/* 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. */ - -static cp_token * -cp_lexer_peek_nth_token (cp_lexer* lexer, size_t n) -{ - cp_token *token; - - /* N is 1-based, not zero-based. */ - gcc_assert (n > 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; - gcc_assert (!n || token != &eof_token); - while (n != 0) - { - ++token; - if (token == lexer->last_token) - { - token = (cp_token *)&eof_token; - break; - } - - /* APPLE LOCAL begin 4137741 */ - if (token->type != CPP_PURGED - && token->type != CPP_BINCL - && token->type != CPP_EINCL) - /* APPLE LOCAL end 4137741 */ - --n; - } - - if (cp_lexer_debugging_p (lexer)) - { - cp_lexer_print_token (cp_lexer_debug_stream, token); - putc ('\n', cp_lexer_debug_stream); - } - - return token; -} - -/* Return the next token, and advance the lexer's next_token pointer - to point to the next non-purged token. */ - -static cp_token * -cp_lexer_consume_token (cp_lexer* lexer) -{ - cp_token *token = lexer->next_token; - - gcc_assert (token != &eof_token); - gcc_assert (!lexer->in_pragma || token->type != CPP_PRAGMA_EOL); - - do - { - lexer->next_token++; - /* APPLE LOCAL 4137741 */ - cp_lexer_consume_bincl_eincl_token (lexer); - if (lexer->next_token == lexer->last_token) - { - lexer->next_token = (cp_token *)&eof_token; - break; - } - - } - while (lexer->next_token->type == CPP_PURGED); - - 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; -} - -/* Permanently remove the next token from the token stream, and - advance the next_token pointer to refer to the next non-purged - token. */ - -static void -cp_lexer_purge_token (cp_lexer *lexer) -{ - cp_token *tok = lexer->next_token; - - gcc_assert (tok != &eof_token); - tok->type = CPP_PURGED; - tok->location = UNKNOWN_LOCATION; - tok->u.value = NULL_TREE; - tok->keyword = RID_MAX; - - do - { - tok++; - if (tok == lexer->last_token) - { - tok = (cp_token *)&eof_token; - break; - } - } - while (tok->type == CPP_PURGED); - lexer->next_token = tok; -} - -/* Permanently remove all tokens after TOK, up to, but not - including, the token that will be returned next by - cp_lexer_peek_token. */ - -static void -cp_lexer_purge_tokens_after (cp_lexer *lexer, cp_token *tok) -{ - cp_token *peek = lexer->next_token; - - if (peek == &eof_token) - peek = lexer->last_token; - - gcc_assert (tok < peek); - - for ( tok += 1; tok != peek; tok += 1) - { - tok->type = CPP_PURGED; - tok->location = UNKNOWN_LOCATION; - tok->u.value = NULL_TREE; - tok->keyword = RID_MAX; - } -} - -/* Begin saving tokens. All tokens consumed after this point will be - preserved. */ - -static void -cp_lexer_save_tokens (cp_lexer* lexer) -{ - /* Provide debugging output. */ - if (cp_lexer_debugging_p (lexer)) - fprintf (cp_lexer_debug_stream, "cp_lexer: saving tokens\n"); - - VEC_safe_push (cp_token_position, heap, - lexer->saved_tokens, lexer->next_token); -} - -/* Commit to the portion of the token stream most recently saved. */ - -static void -cp_lexer_commit_tokens (cp_lexer* lexer) -{ - /* Provide debugging output. */ - if (cp_lexer_debugging_p (lexer)) - fprintf (cp_lexer_debug_stream, "cp_lexer: committing tokens\n"); - - VEC_pop (cp_token_position, lexer->saved_tokens); -} - -/* Return all tokens saved since the last call to cp_lexer_save_tokens - to the token stream. Stop saving tokens. */ - -static void -cp_lexer_rollback_tokens (cp_lexer* lexer) -{ - /* Provide debugging output. */ - if (cp_lexer_debugging_p (lexer)) - fprintf (cp_lexer_debug_stream, "cp_lexer: restoring tokens\n"); - - lexer->next_token = VEC_pop (cp_token_position, lexer->saved_tokens); -} - -/* Print a representation of the TOKEN on the STREAM. */ - -#ifdef ENABLE_CHECKING - -static void -cp_lexer_print_token (FILE * stream, cp_token *token) -{ - /* 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 */ -#define OP(e, s) #e, -#define TK(e, s) #e, - TTYPE_TABLE -#undef OP -#undef TK - /* C++ parser token types - see "Manifest constants", above. */ - "KEYWORD", - "TEMPLATE_ID", - "NESTED_NAME_SPECIFIER", - "PURGED" - }; - - /* If we have a name for the token, print it out. Otherwise, we - simply give the numeric code. */ - gcc_assert (token->type < ARRAY_SIZE(token_names)); - fputs (token_names[token->type], stream); - - /* 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 (TREE_CODE (token->u.value) != IDENTIFIER_NODE) - break; - /* else fall through */ - case CPP_NAME: - fputs (IDENTIFIER_POINTER (token->u.value), stream); - break; - - case CPP_STRING: - case CPP_WSTRING: - fprintf (stream, " \"%s\"", TREE_STRING_POINTER (token->u.value)); - break; - - default: - break; - } -} - -/* Start emitting debugging information. */ - -static void -cp_lexer_start_debugging (cp_lexer* lexer) -{ - lexer->debugging_p = true; -} - -/* Stop emitting debugging information. */ - -static void -cp_lexer_stop_debugging (cp_lexer* lexer) -{ - lexer->debugging_p = false; -} - -#endif /* ENABLE_CHECKING */ - -/* Create a new cp_token_cache, representing a range of tokens. */ - -static cp_token_cache * -cp_token_cache_new (cp_token *first, cp_token *last) -{ - cp_token_cache *cache = GGC_NEW (cp_token_cache); - cache->first = first; - cache->last = last; - return cache; -} - - -/* Decl-specifiers. */ - -/* Set *DECL_SPECS to represent an empty decl-specifier-seq. */ - -static void -clear_decl_specs (cp_decl_specifier_seq *decl_specs) -{ - memset (decl_specs, 0, sizeof (cp_decl_specifier_seq)); -} - -/* Declarators. */ - -/* 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. */ - -static cp_declarator *make_call_declarator - (cp_declarator *, cp_parameter_declarator *, cp_cv_quals, tree); -static cp_declarator *make_array_declarator - (cp_declarator *, tree); -static cp_declarator *make_pointer_declarator - (cp_cv_quals, cp_declarator *); -static cp_declarator *make_reference_declarator - (cp_cv_quals, cp_declarator *); -static cp_parameter_declarator *make_parameter_declarator - (cp_decl_specifier_seq *, cp_declarator *, tree); -static cp_declarator *make_ptrmem_declarator - (cp_cv_quals, tree, cp_declarator *); - -/* An erroneous declarator. */ -static cp_declarator *cp_error_declarator; - -/* The obstack on which declarators and related data structures are - allocated. */ -static struct obstack declarator_obstack; - -/* Alloc BYTES from the declarator memory pool. */ - -static inline void * -alloc_declarator (size_t bytes) -{ - return obstack_alloc (&declarator_obstack, bytes); -} - -/* Allocate a declarator of the indicated KIND. Clear fields that are - common to all declarators. */ - -static cp_declarator * -make_declarator (cp_declarator_kind kind) -{ - cp_declarator *declarator; - - declarator = (cp_declarator *) alloc_declarator (sizeof (cp_declarator)); - declarator->kind = kind; - declarator->attributes = NULL_TREE; - declarator->declarator = NULL; - - return declarator; -} - -/* 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. */ - -static cp_declarator * -make_id_declarator (tree qualifying_scope, tree unqualified_name, - special_function_kind sfk) -{ - 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)) - qualifying_scope = TYPE_MAIN_VARIANT (qualifying_scope); - - gcc_assert (TREE_CODE (unqualified_name) == IDENTIFIER_NODE - || TREE_CODE (unqualified_name) == BIT_NOT_EXPR - || TREE_CODE (unqualified_name) == TEMPLATE_ID_EXPR); - - declarator = make_declarator (cdk_id); - declarator->u.id.qualifying_scope = qualifying_scope; - declarator->u.id.unqualified_name = unqualified_name; - declarator->u.id.sfk = sfk; - - return declarator; -} - -/* 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. */ - -cp_declarator * -make_pointer_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target) -{ - cp_declarator *declarator; - - declarator = make_declarator (cdk_pointer); - declarator->declarator = target; - declarator->u.pointer.qualifiers = cv_qualifiers; - declarator->u.pointer.class_type = NULL_TREE; - - return declarator; -} - -/* Like make_pointer_declarator -- but for references. */ - -cp_declarator * -make_reference_declarator (cp_cv_quals cv_qualifiers, cp_declarator *target) -{ - cp_declarator *declarator; - - declarator = make_declarator (cdk_reference); - declarator->declarator = target; - declarator->u.pointer.qualifiers = cv_qualifiers; - declarator->u.pointer.class_type = NULL_TREE; - - return declarator; -} - -/* Like make_pointer_declarator -- but for a pointer to a non-static - member of CLASS_TYPE. */ - -cp_declarator * -make_ptrmem_declarator (cp_cv_quals cv_qualifiers, tree class_type, - cp_declarator *pointee) -{ - cp_declarator *declarator; - - declarator = make_declarator (cdk_ptrmem); - declarator->declarator = pointee; - declarator->u.pointer.qualifiers = cv_qualifiers; - declarator->u.pointer.class_type = class_type; - - return declarator; -} - -/* Make a declarator for the function given by TARGET, with the - indicated PARMS. The CV_QUALIFIERS aply to the function, as in - "const"-qualified member function. The EXCEPTION_SPECIFICATION - indicates what exceptions can be thrown. */ - -cp_declarator * -make_call_declarator (cp_declarator *target, - cp_parameter_declarator *parms, - cp_cv_quals cv_qualifiers, - tree exception_specification) -{ - 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.exception_specification = exception_specification; - - return declarator; -} - -/* Make a declarator for an array of BOUNDS elements, each of which is - defined by ELEMENT. */ - -cp_declarator * -make_array_declarator (cp_declarator *element, tree bounds) -{ - cp_declarator *declarator; - - declarator = make_declarator (cdk_array); - declarator->declarator = element; - declarator->u.array.bounds = bounds; - - return declarator; -} - -cp_parameter_declarator *no_parameters; - -/* Create a parameter declarator with the indicated DECL_SPECIFIERS, - DECLARATOR and DEFAULT_ARGUMENT. */ - -cp_parameter_declarator * -make_parameter_declarator (cp_decl_specifier_seq *decl_specifiers, - cp_declarator *declarator, - tree default_argument) -{ - cp_parameter_declarator *parameter; - - parameter = ((cp_parameter_declarator *) - alloc_declarator (sizeof (cp_parameter_declarator))); - parameter->next = NULL; - if (decl_specifiers) - parameter->decl_specifiers = *decl_specifiers; - else - clear_decl_specs (¶meter->decl_specifiers); - parameter->declarator = declarator; - parameter->default_argument = default_argument; - parameter->ellipsis_p = false; - - return parameter; -} - -/* Returns true iff DECLARATOR is a declaration for a function. */ - -static bool -function_declarator_p (const cp_declarator *declarator) -{ - while (declarator) - { - if (declarator->kind == cdk_function - && declarator->declarator->kind == cdk_id) - return true; - if (declarator->kind == cdk_id - || declarator->kind == cdk_error) - return false; - declarator = declarator->declarator; - } - return false; -} - -/* The parser. */ - -/* 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. */ - -/* Flags that are passed to some parsing functions. These values can - be bitwise-ored together. */ - -typedef enum cp_parser_flags -{ - /* 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, do not allow user-defined types. */ - CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES = 0x2 -} cp_parser_flags; - -/* The different kinds of declarators we want to parse. */ - -typedef enum cp_parser_declarator_kind -{ - /* APPLE LOCAL begin blocks 6339747 */ - /* We want a block declarator. */ - CP_PARSER_DECLARATOR_BLOCK, - /* APPLE LOCAL end blocks 6339747 */ - /* 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 -} cp_parser_declarator_kind; - -/* 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. */ - -enum cp_parser_prec -{ - 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_SHIFT_EXPRESSION, - PREC_ADDITIVE_EXPRESSION, - PREC_MULTIPLICATIVE_EXPRESSION, - PREC_PM_EXPRESSION, - NUM_PREC_VALUES = PREC_PM_EXPRESSION -}; - -/* A mapping from a token type to a corresponding tree node type, with a - precedence value. */ - -typedef struct cp_parser_binary_operations_map_node -{ - /* 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; -} cp_parser_binary_operations_map_node; - -/* The status of a tentative parse. */ - -typedef enum cp_parser_status_kind -{ - /* No errors have occurred. */ - CP_PARSER_STATUS_KIND_NO_ERROR, - /* An error has occurred. */ - CP_PARSER_STATUS_KIND_ERROR, - /* We are committed to this tentative parse, whether or not an error - has occurred. */ - CP_PARSER_STATUS_KIND_COMMITTED -} cp_parser_status_kind; - -typedef struct cp_parser_expression_stack_entry -{ - tree lhs; - enum tree_code tree_type; - int prec; -} cp_parser_expression_stack_entry; - -/* The stack for storing partial expressions. We only need NUM_PREC_VALUES - entries because precedence levels on the stack are monotonically - increasing. */ -typedef struct cp_parser_expression_stack_entry - cp_parser_expression_stack[NUM_PREC_VALUES]; - -/* Context that is saved and restored when parsing tentatively. */ -typedef struct cp_parser_context GTY (()) -{ - /* If this is a tentative parsing context, the status of the - tentative parse. */ - enum cp_parser_status_kind status; - /* If non-NULL, we have just seen a `x->' or `x.' expression. Names - that are looked up in this context must be looked up both in the - scope given by OBJECT_TYPE (the type of `x' or `*x') and also in - the context of the containing expression. */ - tree object_type; - - /* The next parsing context in the stack. */ - struct cp_parser_context *next; -} cp_parser_context; - -/* Prototypes. */ - -/* Constructors and destructors. */ - -static cp_parser_context *cp_parser_context_new - (cp_parser_context *); - -/* Class variables. */ - -static GTY((deletable)) cp_parser_context* cp_parser_context_free_list; - -/* The operator-precedence table used by cp_parser_binary_expression. - Transformed into an associative array (binops_by_token) by - cp_parser_new. */ - -static 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_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 } -}; - -/* 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. */ -static cp_parser_binary_operations_map_node binops_by_token[N_CP_TTYPES]; - -/* Constructors and destructors. */ - -/* Construct a new context. The context below this one on the stack - is given by NEXT. */ - -static cp_parser_context * -cp_parser_context_new (cp_parser_context* next) -{ - cp_parser_context *context; - - /* Allocate the storage. */ - if (cp_parser_context_free_list != 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_CNEW (cp_parser_context); - - /* No errors have occurred yet in this context. */ - context->status = CP_PARSER_STATUS_KIND_NO_ERROR; - /* If this is not the bottomost 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; -} - -/* The cp_parser structure represents the C++ parser. */ - -typedef struct cp_parser GTY(()) -{ - /* The lexer from which we are obtaining tokens. */ - cp_lexer *lexer; - - /* The scope in which names should be looked up. If NULL_TREE, then - we look up names in the scope that is currently open in the - source program. If non-NULL, this is either a TYPE or - NAMESPACE_DECL for the scope in which we should look. It can - also be ERROR_MARK, when we've parsed a bogus scope. - - This value is not cleared automatically after a name is looked - up, so we must be careful to clear it before starting a new look - up sequence. (If it is not cleared, then `X::Y' followed by `Z' - will look up `Z' in the scope of `X', rather than the current - scope.) Unfortunately, it is difficult to tell when name lookup - is complete, because we sometimes peek at a token, look it up, - and then decide not to consume it. */ - tree scope; - - /* OBJECT_SCOPE and QUALIFYING_SCOPE give the scopes in which the - last lookup took place. OBJECT_SCOPE is used if an expression - like "x->y" or "x.y" was used; it gives the type of "*x" or "x", - respectively. QUALIFYING_SCOPE is used for an expression of the - form "X::Y"; it refers to X. */ - tree object_scope; - tree qualifying_scope; - - /* A stack of parsing contexts. All but the bottom entry on the - stack will be tentative contexts. - - We parse tentatively in order to determine which construct is in - use in some situations. For example, in order to determine - whether a statement is an expression-statement or a - declaration-statement we parse it tentatively as a - declaration-statement. If that fails, we then reparse the same - token stream as an expression-statement. */ - cp_parser_context *context; - - /* True if we are parsing GNU C++. If this flag is not set, then - GNU extensions are not recognized. */ - bool allow_gnu_extensions_p; - - /* TRUE if the `>' token should be interpreted as the greater-than - operator. FALSE if it is the end of a template-id or - template-parameter-list. */ - bool greater_than_is_operator_p; - - /* TRUE if default arguments are allowed within a parameter list - that starts at this point. FALSE if only a gnu extension makes - them permissible. */ - bool default_arg_ok_p; - - /* TRUE if we are parsing an integral constant-expression. See - [expr.const] for a precise definition. */ - bool integral_constant_expression_p; - - /* TRUE if we are parsing an integral constant-expression -- but a - non-constant expression should be permitted as well. This flag - is used when parsing an array bound so that GNU variable-length - arrays are tolerated. */ - bool allow_non_integral_constant_expression_p; - - /* TRUE if ALLOW_NON_CONSTANT_EXPRESSION_P is TRUE and something has - been seen that makes the expression non-constant. */ - bool non_integral_constant_expression_p; - - /* TRUE if local variable names and `this' are forbidden in the - current context. */ - bool local_variables_forbidden_p; - - /* TRUE if the declaration we are parsing is part of a - linkage-specification of the form `extern string-literal - declaration'. */ - bool in_unbraced_linkage_specification_p; - - /* TRUE if we are presently parsing a declarator, after the - direct-declarator. */ - bool in_declarator_p; - - /* TRUE if we are presently parsing a template-argument-list. */ - bool in_template_argument_list_p; - - /* Set to IN_ITERATION_STMT if parsing an iteration-statement, - to IN_OMP_BLOCK if parsing OpenMP structured block and - IN_OMP_FOR if parsing OpenMP loop. If parsing a switch statement, - this is bitwise ORed with IN_SWITCH_STMT, unless parsing an - iteration-statement, OpenMP block or loop within that switch. */ -#define IN_SWITCH_STMT 1 -#define IN_ITERATION_STMT 2 -#define IN_OMP_BLOCK 4 -#define IN_OMP_FOR 8 - unsigned char in_statement; - - /* TRUE if we are presently parsing the body of a switch statement. - Note that this doesn't quite overlap with in_statement above. - The difference relates to giving the right sets of error messages: - "case not in switch" vs "break statement used with OpenMP...". */ - bool in_switch_statement_p; - - /* TRUE if we are parsing a type-id in an expression context. In - such a situation, both "type (expr)" and "type (type)" are valid - alternatives. */ - bool in_type_id_in_expr_p; - - /* TRUE if we are currently in a header file where declarations are - implicitly extern "C". */ - bool implicit_extern_c; - - /* TRUE if strings in expressions should be translated to the execution - character set. */ - bool translate_strings_p; - - /* TRUE if we are presently parsing the body of a function, but not - a local class. */ - bool in_function_body; - - /* If non-NULL, then we are parsing a construct where new type - definitions are not permitted. The string stored here will be - issued as an error message if a type is defined. */ - const char *type_definition_forbidden_message; - - /* A list of lists. The outer list is a stack, used for member - functions of local classes. At each level there are two sub-list, - one on TREE_VALUE and one on TREE_PURPOSE. Each of those - sub-lists has a FUNCTION_DECL or TEMPLATE_DECL on their - TREE_VALUE's. The functions are chained in reverse declaration - order. - - The TREE_PURPOSE sublist contains those functions with default - arguments that need post processing, and the TREE_VALUE sublist - contains those functions with definitions that need post - processing. - - These lists can only be processed once the outermost class being - defined is complete. */ - tree unparsed_functions_queues; - - /* The number of classes whose definitions are currently in - progress. */ - unsigned num_classes_being_defined; - - /* The number of template parameter lists that apply directly to the - current declaration. */ - unsigned num_template_parameter_lists; -} cp_parser; - -/* Prototypes. */ - -/* Constructors and destructors. */ - -static cp_parser *cp_parser_new - (void); - -/* 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. */ - -/* Lexical conventions [gram.lex] */ - -static tree cp_parser_identifier - (cp_parser *); -static tree cp_parser_string_literal - (cp_parser *, bool, bool); - -/* Basic concepts [gram.basic] */ - -static bool cp_parser_translation_unit - (cp_parser *); - -/* Expressions [gram.expr] */ - -static tree cp_parser_primary_expression - (cp_parser *, bool, bool, bool, cp_id_kind *); -static tree cp_parser_id_expression - (cp_parser *, bool, bool, bool *, bool, bool); -static tree cp_parser_unqualified_id - (cp_parser *, bool, bool, bool, bool); -static tree cp_parser_nested_name_specifier_opt - (cp_parser *, bool, bool, bool, bool); -static tree cp_parser_nested_name_specifier - (cp_parser *, bool, bool, bool, bool); -static tree cp_parser_class_or_namespace_name - (cp_parser *, bool, bool, bool, bool, bool); -static tree cp_parser_postfix_expression - (cp_parser *, bool, bool); -static tree cp_parser_postfix_open_square_expression - (cp_parser *, tree, bool); -static tree cp_parser_postfix_dot_deref_expression - (cp_parser *, enum cpp_ttype, tree, bool, cp_id_kind *); -static tree cp_parser_parenthesized_expression_list - (cp_parser *, bool, bool, bool *); -static void cp_parser_pseudo_destructor_name - (cp_parser *, tree *, tree *); -static tree cp_parser_unary_expression - (cp_parser *, bool, bool); -static enum tree_code cp_parser_unary_operator - (cp_token *); -static tree cp_parser_new_expression - (cp_parser *); -static tree cp_parser_new_placement - (cp_parser *); -static tree cp_parser_new_type_id - (cp_parser *, tree *); -static cp_declarator *cp_parser_new_declarator_opt - (cp_parser *); -static cp_declarator *cp_parser_direct_new_declarator - (cp_parser *); -static tree cp_parser_new_initializer - (cp_parser *); -static tree cp_parser_delete_expression - (cp_parser *); -static tree cp_parser_cast_expression - (cp_parser *, bool, bool); -static tree cp_parser_binary_expression - (cp_parser *, bool); -static tree cp_parser_question_colon_clause - (cp_parser *, tree); -static tree cp_parser_assignment_expression - (cp_parser *, bool); -static enum tree_code cp_parser_assignment_operator_opt - (cp_parser *); -static tree cp_parser_expression - (cp_parser *, bool); -static tree cp_parser_constant_expression - (cp_parser *, bool, bool *); -static tree cp_parser_builtin_offsetof - (cp_parser *); -/* APPLE LOCAL begin blocks 6040305 (ca) */ -static tree cp_parser_block_literal_expr (cp_parser *); -/* APPLE LOCAL end blocks 6040305 (ca) */ -/* APPLE LOCAL begin C* language */ -static void objc_foreach_stmt - (cp_parser *, tree); -/* APPLE LOCAL end C* language */ -/* APPLE LOCAL begin C* property (Radar 4436866) */ -static void objc_cp_parser_at_property - (cp_parser *); -static void objc_cp_parse_property_decl - (cp_parser *); -/* APPLE LOCAL end C* property (Radar 4436866) */ -/* APPLE LOCAL begin objc new property */ -static void objc_cp_parser_property_impl (cp_parser *parser, - enum rid keyword); -/* APPLE LOCAL end objc new property */ -/* APPLE LOCAL begin radar 4548636 */ -static bool objc_attr_follwed_by_at_keyword - (cp_parser *); -/* APPLE LOCAL end radar 4548636 */ - -/* Statements [gram.stmt.stmt] */ - -static void cp_parser_statement - (cp_parser *, tree, bool); -static void cp_parser_label_for_labeled_statement - (cp_parser *); -static tree cp_parser_expression_statement - (cp_parser *, tree); -static tree cp_parser_compound_statement - /* APPLE LOCAL radar 5982990 */ - (cp_parser *, tree, bool, bool); -static void cp_parser_statement_seq_opt - (cp_parser *, tree); -static tree cp_parser_selection_statement - (cp_parser *); -static tree cp_parser_condition - (cp_parser *); -static tree cp_parser_iteration_statement - (cp_parser *); -static void cp_parser_for_init_statement - (cp_parser *); -static tree cp_parser_jump_statement - (cp_parser *); -static void cp_parser_declaration_statement - (cp_parser *); - -static tree cp_parser_implicitly_scoped_statement - (cp_parser *); -static void cp_parser_already_scoped_statement - (cp_parser *); - -/* Declarations [gram.dcl.dcl] */ - -static void cp_parser_declaration_seq_opt - (cp_parser *); -static void cp_parser_declaration - (cp_parser *); -static void cp_parser_block_declaration - (cp_parser *, bool); -static void cp_parser_simple_declaration - (cp_parser *, bool); -static void cp_parser_decl_specifier_seq - (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, int *); -static tree cp_parser_storage_class_specifier_opt - (cp_parser *); -static tree cp_parser_function_specifier_opt - (cp_parser *, cp_decl_specifier_seq *); -static tree cp_parser_type_specifier - (cp_parser *, cp_parser_flags, cp_decl_specifier_seq *, bool, - int *, bool *); -static tree cp_parser_simple_type_specifier - (cp_parser *, cp_decl_specifier_seq *, cp_parser_flags); -static tree cp_parser_type_name - (cp_parser *); -static tree cp_parser_elaborated_type_specifier - (cp_parser *, bool, bool); -static tree cp_parser_enum_specifier - (cp_parser *); -static void cp_parser_enumerator_list - (cp_parser *, tree); -static void cp_parser_enumerator_definition - (cp_parser *, tree); -static tree cp_parser_namespace_name - (cp_parser *); -static void cp_parser_namespace_definition - (cp_parser *); -static void cp_parser_namespace_body - (cp_parser *); -static tree cp_parser_qualified_namespace_specifier - (cp_parser *); -static void cp_parser_namespace_alias_definition - (cp_parser *); -static bool cp_parser_using_declaration - (cp_parser *, bool); -static void cp_parser_using_directive - (cp_parser *); -static void cp_parser_asm_definition - /* APPLE LOCAL CW asm blocks */ - (cp_parser *, bool); -static void cp_parser_linkage_specification - (cp_parser *); - -/* Declarators [gram.dcl.decl] */ - -static tree cp_parser_init_declarator - (cp_parser *, cp_decl_specifier_seq *, VEC (deferred_access_check,gc)*, bool, bool, int, bool *); -static cp_declarator *cp_parser_declarator - (cp_parser *, cp_parser_declarator_kind, int *, bool *, bool); -static cp_declarator *cp_parser_direct_declarator - (cp_parser *, cp_parser_declarator_kind, int *, bool); -static enum tree_code cp_parser_ptr_operator - (cp_parser *, tree *, cp_cv_quals *); -static cp_cv_quals cp_parser_cv_qualifier_seq_opt - (cp_parser *); -static tree cp_parser_declarator_id - (cp_parser *, bool); -static tree cp_parser_type_id - (cp_parser *); -static void cp_parser_type_specifier_seq - (cp_parser *, bool, cp_decl_specifier_seq *); -static cp_parameter_declarator *cp_parser_parameter_declaration_clause - (cp_parser *); -static cp_parameter_declarator *cp_parser_parameter_declaration_list - (cp_parser *, bool *); -static cp_parameter_declarator *cp_parser_parameter_declaration - (cp_parser *, bool, bool *); -static void cp_parser_function_body - (cp_parser *); -static tree cp_parser_initializer - (cp_parser *, bool *, bool *); -static tree cp_parser_initializer_clause - (cp_parser *, bool *); -static VEC(constructor_elt,gc) *cp_parser_initializer_list - (cp_parser *, bool *); - -static bool cp_parser_ctor_initializer_opt_and_function_body - (cp_parser *); - -/* Classes [gram.class] */ - -static tree cp_parser_class_name - (cp_parser *, bool, bool, enum tag_types, bool, bool, bool); -static tree cp_parser_class_specifier - (cp_parser *); -static tree cp_parser_class_head - (cp_parser *, bool *, tree *, tree *); -static enum tag_types cp_parser_class_key - (cp_parser *); -static void cp_parser_member_specification_opt - (cp_parser *); -static void cp_parser_member_declaration - (cp_parser *); -static tree cp_parser_pure_specifier - (cp_parser *); -static tree cp_parser_constant_initializer - (cp_parser *); - -/* Derived classes [gram.class.derived] */ - -static tree cp_parser_base_clause - (cp_parser *); -static tree cp_parser_base_specifier - (cp_parser *); - -/* Special member functions [gram.special] */ - -static tree cp_parser_conversion_function_id - (cp_parser *); -static tree cp_parser_conversion_type_id - (cp_parser *); -static cp_declarator *cp_parser_conversion_declarator_opt - (cp_parser *); -static bool cp_parser_ctor_initializer_opt - (cp_parser *); -static void cp_parser_mem_initializer_list - (cp_parser *); -static tree cp_parser_mem_initializer - (cp_parser *); -static tree cp_parser_mem_initializer_id - (cp_parser *); - -/* Overloading [gram.over] */ - -static tree cp_parser_operator_function_id - (cp_parser *); -static tree cp_parser_operator - (cp_parser *); - -/* Templates [gram.temp] */ - -static void cp_parser_template_declaration - (cp_parser *, bool); -static tree cp_parser_template_parameter_list - (cp_parser *); -static tree cp_parser_template_parameter - (cp_parser *, bool *); -static tree cp_parser_type_parameter - (cp_parser *); -static tree cp_parser_template_id - (cp_parser *, bool, bool, bool); -static tree cp_parser_template_name - (cp_parser *, bool, bool, bool, bool *); -static tree cp_parser_template_argument_list - (cp_parser *); -static tree cp_parser_template_argument - (cp_parser *); -static void cp_parser_explicit_instantiation - (cp_parser *); -static void cp_parser_explicit_specialization - (cp_parser *); - -/* Exception handling [gram.exception] */ - -static tree cp_parser_try_block - (cp_parser *); -static bool cp_parser_function_try_block - (cp_parser *); -static void cp_parser_handler_seq - (cp_parser *); -static void cp_parser_handler - (cp_parser *); -static tree cp_parser_exception_declaration - (cp_parser *); -static tree cp_parser_throw_expression - (cp_parser *); -static tree cp_parser_exception_specification_opt - (cp_parser *); -static tree cp_parser_type_id_list - (cp_parser *); - -/* GNU Extensions */ - -static tree cp_parser_asm_specification_opt - (cp_parser *); -static tree cp_parser_asm_operand_list - (cp_parser *); -static tree cp_parser_asm_clobber_list - (cp_parser *); -static tree cp_parser_attributes_opt - (cp_parser *); -static tree cp_parser_attribute_list - (cp_parser *); -static bool cp_parser_extension_opt - (cp_parser *, int *); -static void cp_parser_label_declaration - (cp_parser *); - -enum pragma_context { pragma_external, pragma_stmt, pragma_compound }; -static bool cp_parser_pragma - (cp_parser *, enum pragma_context); - -/* Objective-C++ Productions */ - -static tree cp_parser_objc_message_receiver - (cp_parser *); -static tree cp_parser_objc_message_args - (cp_parser *); -static tree cp_parser_objc_message_expression - (cp_parser *); -/* APPLE LOCAL begin radar 5277239 */ -static tree cp_parser_objc_reference_expression - (cp_parser *, tree); -/* APPLE LOCAL end radar 5277239 */ -static tree cp_parser_objc_encode_expression - (cp_parser *); -static tree cp_parser_objc_defs_expression - (cp_parser *); -static tree cp_parser_objc_protocol_expression - (cp_parser *); -static tree cp_parser_objc_selector_expression - (cp_parser *); -static tree cp_parser_objc_expression - (cp_parser *); -static bool cp_parser_objc_selector_p - (enum cpp_ttype); -static tree cp_parser_objc_selector - (cp_parser *); -/* APPLE LOCAL begin radar 3803157 - objc attribute */ -static void cp_parser_objc_maybe_attributes - (cp_parser *, tree *); -static tree cp_parser_objc_identifier_list - (cp_parser *); -/* APPLE LOCAL end radar 3803157 - objc attribute */ -static tree cp_parser_objc_protocol_refs_opt - (cp_parser *); -/* APPLE LOCAL begin radar 5355344 */ -static bool cp_parser_objc_tentative_protocol_refs_opt - (cp_parser *, tree *); -/* APPLE LOCAL end radar 5355344 */ -static void cp_parser_objc_declaration - (cp_parser *); -static tree cp_parser_objc_statement - (cp_parser *); - -/* Utility Routines */ - -static tree cp_parser_lookup_name - (cp_parser *, tree, enum tag_types, bool, bool, bool, tree *); -static tree cp_parser_lookup_name_simple - (cp_parser *, tree); -static tree cp_parser_maybe_treat_template_as_class - (tree, bool); -static bool cp_parser_check_declarator_template_parameters - (cp_parser *, cp_declarator *); -static bool cp_parser_check_template_parameters - (cp_parser *, unsigned); -static tree cp_parser_simple_cast_expression - (cp_parser *); -static tree cp_parser_global_scope_opt - (cp_parser *, bool); -static bool cp_parser_constructor_declarator_p - (cp_parser *, bool); -static tree cp_parser_function_definition_from_specifiers_and_declarator - (cp_parser *, cp_decl_specifier_seq *, tree, const cp_declarator *); -static tree cp_parser_function_definition_after_declarator - (cp_parser *, bool); -static void cp_parser_template_declaration_after_export - (cp_parser *, bool); -static void cp_parser_perform_template_parameter_access_checks - (VEC (deferred_access_check,gc)*); -static tree cp_parser_single_declaration - (cp_parser *, VEC (deferred_access_check,gc)*, bool, bool *); -static tree cp_parser_functional_cast - (cp_parser *, tree); -static tree cp_parser_save_member_function_body - (cp_parser *, cp_decl_specifier_seq *, cp_declarator *, tree); -static tree cp_parser_enclosed_template_argument_list - (cp_parser *); -static void cp_parser_save_default_args - (cp_parser *, tree); -static void cp_parser_late_parsing_for_member - (cp_parser *, tree); -static void cp_parser_late_parsing_default_args - (cp_parser *, tree); -static tree cp_parser_sizeof_operand - (cp_parser *, enum rid); -static bool cp_parser_declares_only_class_p - (cp_parser *); -static void cp_parser_set_storage_class - (cp_parser *, cp_decl_specifier_seq *, enum rid); -static void cp_parser_set_decl_spec_type - (cp_decl_specifier_seq *, tree, bool); -static bool cp_parser_friend_p - (const cp_decl_specifier_seq *); -static cp_token *cp_parser_require - (cp_parser *, enum cpp_ttype, const char *); -static cp_token *cp_parser_require_keyword - (cp_parser *, enum rid, const char *); -static bool cp_parser_token_starts_function_definition_p - (cp_token *); -static bool cp_parser_next_token_starts_class_definition_p - (cp_parser *); -static bool cp_parser_next_token_ends_template_argument_p - (cp_parser *); -static bool cp_parser_nth_token_starts_template_argument_list_p - (cp_parser *, size_t); -static enum tag_types cp_parser_token_is_class_key - (cp_token *); -static void cp_parser_check_class_key - (enum tag_types, tree type); -static void cp_parser_check_access_in_redeclaration - (tree type); -static bool cp_parser_optional_template_keyword - (cp_parser *); -static void cp_parser_pre_parsed_nested_name_specifier - (cp_parser *); -static void cp_parser_cache_group - (cp_parser *, enum cpp_ttype, unsigned); -static void cp_parser_parse_tentatively - (cp_parser *); -static void cp_parser_commit_to_tentative_parse - (cp_parser *); -static void cp_parser_abort_tentative_parse - (cp_parser *); -static bool cp_parser_parse_definitely - (cp_parser *); -static inline bool cp_parser_parsing_tentatively - (cp_parser *); -static bool cp_parser_uncommitted_to_tentative_parse_p - (cp_parser *); -static void cp_parser_error - (cp_parser *, const char *); -static void cp_parser_name_lookup_error - (cp_parser *, tree, tree, const char *); -static bool cp_parser_simulate_error - (cp_parser *); -static bool cp_parser_check_type_definition - (cp_parser *); -static void cp_parser_check_for_definition_in_return_type - (cp_declarator *, tree); -static void cp_parser_check_for_invalid_template_id - (cp_parser *, tree); -static bool cp_parser_non_integral_constant_expression - (cp_parser *, const char *); -static void cp_parser_diagnose_invalid_type_name - (cp_parser *, tree, tree); -static bool cp_parser_parse_and_diagnose_invalid_type_name - (cp_parser *); -static int cp_parser_skip_to_closing_parenthesis - (cp_parser *, bool, bool, bool); -static void cp_parser_skip_to_end_of_statement - (cp_parser *); -static void cp_parser_consume_semicolon_at_end_of_statement - (cp_parser *); -static void cp_parser_skip_to_end_of_block_or_statement - (cp_parser *); -static void cp_parser_skip_to_closing_brace - (cp_parser *); -static void cp_parser_skip_to_end_of_template_parameter_list - (cp_parser *); -static void cp_parser_skip_to_pragma_eol - (cp_parser*, cp_token *); -static bool cp_parser_error_occurred - (cp_parser *); -static bool cp_parser_allow_gnu_extensions_p - (cp_parser *); -static bool cp_parser_is_string_literal - (cp_token *); -static bool cp_parser_is_keyword - (cp_token *, enum rid); -static tree cp_parser_make_typename_type - (cp_parser *, tree, tree); - -/* APPLE LOCAL begin CW asm blocks */ -static tree cp_parser_iasm_compound_statement - (cp_parser *); -static void cp_parser_iasm_declaration_seq_opt - (cp_parser *); -static void cp_parser_iasm_line_seq_opt - (cp_parser *); -static void cp_parser_iasm_line - (cp_parser *); -static void cp_parser_iasm_statement_seq_opt - (cp_parser *); -static void cp_parser_iasm_statement - (cp_parser *); -static tree cp_parser_iasm_operands - (cp_parser *); -static tree cp_parser_iasm_operand - (cp_parser *); -static tree cp_parser_iasm_postfix_expression - (cp_parser *, bool, bool); -static tree cp_parser_iasm_identifier_or_number - (cp_parser* parser); -static tree iasm_build_identifier_string - (cp_parser* parser, const char* str); -static tree cp_parser_iasm_relative_branch - (cp_parser *parser); -static void cp_parser_iasm_top_statement - (cp_parser *parser); - -#ifndef IASM_SEE_OPCODE -#define IASM_SEE_OPCODE(YYCHAR, T) YYCHAR -#endif -#define TYPESPEC 1 -#define IDENTIFIER 2 -/* APPLE LOCAL end CW asm blocks */ - -/* Returns nonzero if we are parsing tentatively. */ - -static inline bool -cp_parser_parsing_tentatively (cp_parser* parser) -{ - return parser->context->next != NULL; -} - -/* Returns nonzero if TOKEN is a string literal. */ - -static bool -cp_parser_is_string_literal (cp_token* token) -{ - return (token->type == CPP_STRING || token->type == CPP_WSTRING); -} - -/* Returns nonzero if TOKEN is the indicated KEYWORD. */ - -static bool -cp_parser_is_keyword (cp_token* token, enum rid keyword) -{ - return token->keyword == keyword; -} - -/* 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". */ - -static void -cp_parser_error (cp_parser* parser, const char* message) -{ - if (!cp_parser_simulate_error (parser)) - { - 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 ("%<#pragma%> is not allowed here"); - cp_parser_skip_to_pragma_eol (parser, token); - return; - } - - c_parse_error (message, - /* 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); - } -} - -/* 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. */ - -static void -cp_parser_name_lookup_error (cp_parser* parser, - tree name, - tree decl, - const char* desired) -{ - /* If name lookup completely failed, tell the user that NAME was not - declared. */ - if (decl == error_mark_node) - { - if (parser->scope && parser->scope != global_namespace) - error ("%<%D::%D%> has not been declared", - parser->scope, name); - else if (parser->scope == global_namespace) - error ("%<::%D%> has not been declared", name); - else if (parser->object_scope - && !CLASS_TYPE_P (parser->object_scope)) - error ("request for member %qD in non-class type %qT", - name, parser->object_scope); - else if (parser->object_scope) - error ("%<%T::%D%> has not been declared", - parser->object_scope, name); - else - error ("%qD has not been declared", name); - } - else if (parser->scope && parser->scope != global_namespace) - error ("%<%D::%D%> %s", parser->scope, name, desired); - else if (parser->scope == global_namespace) - error ("%<::%D%> %s", name, desired); - else - error ("%qD %s", name, desired); -} - -/* 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. */ - -static bool -cp_parser_simulate_error (cp_parser* parser) -{ - if (cp_parser_uncommitted_to_tentative_parse_p (parser)) - { - parser->context->status = CP_PARSER_STATUS_KIND_ERROR; - return true; - } - return false; -} - -/* Check for repeated decl-specifiers. */ - -static void -cp_parser_check_decl_spec (cp_decl_specifier_seq *decl_specs) -{ - cp_decl_spec ds; - - for (ds = ds_first; ds != ds_last; ++ds) - { - unsigned count = decl_specs->specs[(int)ds]; - if (count < 2) - continue; - /* The "long" specifier is a special case because of "long long". */ - if (ds == ds_long) - { - if (count > 2) - error ("%<long long long%> is too long for GCC"); - else if (pedantic && !in_system_header && warn_long_long) - pedwarn ("ISO C++ does not support %<long long%>"); - } - else if (count > 1) - { - static const char *const decl_spec_names[] = { - "signed", - "unsigned", - "short", - "long", - "const", - "volatile", - "restrict", - "inline", - "virtual", - "explicit", - "friend", - "typedef", - "__complex", - "__thread" - /* APPLE LOCAL CW asm blocks */ - , "asm" - }; - error ("duplicate %qs", decl_spec_names[(int)ds]); - } - } -} - -/* This function is called when a type is defined. If type - definitions are forbidden at this point, an error message is - issued. */ - -static bool -cp_parser_check_type_definition (cp_parser* parser) -{ - /* If types are forbidden here, issue a message. */ - if (parser->type_definition_forbidden_message) - { - /* Use `%s' to print the string in case there are any escape - characters in the message. */ - error ("%s", parser->type_definition_forbidden_message); - return false; - } - return true; -} - -/* 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. */ - -static void -cp_parser_check_for_definition_in_return_type (cp_declarator *declarator, - tree type) -{ - /* [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 ("new types may not be defined in a return type"); - inform ("(perhaps a semicolon is missing after the definition of %qT)", - type); - } -} - -/* 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. */ - -static void -cp_parser_check_for_invalid_template_id (cp_parser* parser, - tree type) -{ - cp_token_position start = 0; - - if (cp_lexer_next_token_is (parser->lexer, CPP_LESS)) - { - if (TYPE_P (type)) - error ("%qT is not a template", type); - else if (TREE_CODE (type) == IDENTIFIER_NODE) - error ("%qE is not a template", type); - else - error ("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); - } -} - -/* 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. */ - -static bool -cp_parser_non_integral_constant_expression (cp_parser *parser, - const char *thing) -{ - parser->non_integral_constant_expression_p = true; - if (parser->integral_constant_expression_p) - { - if (!parser->allow_non_integral_constant_expression_p) - { - error ("%s cannot appear in a constant-expression", thing); - return true; - } - } - return false; -} - -/* Emit a diagnostic for an invalid type name. SCOPE is the - qualifying scope (or NULL, if none) for ID. 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.) */ - -static void -cp_parser_diagnose_invalid_type_name (cp_parser *parser, tree scope, tree id) -{ - tree decl, old_scope; - /* Try to lookup the identifier. */ - old_scope = parser->scope; - parser->scope = scope; - decl = cp_parser_lookup_name_simple (parser, id); - parser->scope = old_scope; - /* If the lookup found a template-name, it means that the user forgot - to specify an argument list. Emit a useful error message. */ - if (TREE_CODE (decl) == TEMPLATE_DECL) - error ("invalid use of template-name %qE without an argument list", decl); - else if (TREE_CODE (id) == BIT_NOT_EXPR) - error ("invalid use of destructor %qD as a type", id); - else if (TREE_CODE (decl) == TYPE_DECL) - /* Something like 'unsigned A a;' */ - error ("invalid combination of multiple type-specifiers"); - else if (!parser->scope) - { - /* Issue an error message. */ - error ("%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 (processing_template_decl && current_class_type - && TYPE_BINFO (current_class_type)) - { - tree b; - - for (b = TREE_CHAIN (TYPE_BINFO (current_class_type)); - b; - b = TREE_CHAIN (b)) - { - tree base_type = BINFO_TYPE (b); - if (CLASS_TYPE_P (base_type) - && dependent_type_p (base_type)) - { - tree field; - /* 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); - for (field = TYPE_FIELDS (base_type); - field; - field = TREE_CHAIN (field)) - if (TREE_CODE (field) == TYPE_DECL - && DECL_NAME (field) == id) - { - inform ("(perhaps %<typename %T::%E%> was intended)", - BINFO_TYPE (b), id); - break; - } - if (field) - break; - } - } - } - } - /* 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_node) - { - if (TREE_CODE (parser->scope) == NAMESPACE_DECL) - error ("%qE in namespace %qE does not name a type", - id, parser->scope); - else if (TYPE_P (parser->scope)) - error ("%qE in class %qT does not name a type", id, parser->scope); - else - gcc_unreachable (); - } - cp_parser_commit_to_tentative_parse (parser); -} - -/* 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. */ - -static bool -cp_parser_parse_and_diagnose_invalid_type_name (cp_parser *parser) -{ - tree id; - - cp_parser_parse_tentatively (parser); - id = cp_parser_id_expression (parser, - /*template_keyword_p=*/false, - /*check_dependency_p=*/true, - /*template_p=*/NULL, - /*declarator_p=*/true, - /*optional_p=*/false); - /* After the id-expression, there should be a plain identifier, - otherwise this is not a simple variable declaration. Also, if - the scope is dependent, we cannot do much. */ - if (!cp_lexer_next_token_is (parser->lexer, CPP_NAME) - || (parser->scope && TYPE_P (parser->scope) - && dependent_type_p (parser->scope)) - || TREE_CODE (id) == 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, parser->scope, id); - /* Skip to the end of the declaration; there's no point in - trying to process it. */ - cp_parser_skip_to_end_of_block_or_statement (parser); - return true; -} - -/* 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 comma. */ - -static int -cp_parser_skip_to_closing_parenthesis (cp_parser *parser, - bool recovering, - bool or_comma, - bool consume_paren) -{ - unsigned paren_depth = 0; - unsigned brace_depth = 0; - - if (recovering && !or_comma - && cp_parser_uncommitted_to_tentative_parse_p (parser)) - return 0; - - while (true) - { - cp_token * token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_EOF: - case CPP_PRAGMA_EOL: - /* If we've run out of tokens, then there is no closing `)'. */ - return 0; - - 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_COMMA: - if (recovering && or_comma && !brace_depth && !paren_depth) - return -1; - 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; - - default: - break; - } - - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - } -} - -/* 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. */ - -static void -cp_parser_skip_to_end_of_statement (cp_parser* parser) -{ - unsigned nesting_depth = 0; - - while (true) - { - cp_token *token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_EOF: - case CPP_PRAGMA_EOL: - /* 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; - } - - case CPP_OPEN_BRACE: - ++nesting_depth; - break; - - default: - break; - } - - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - } -} - -/* APPLE LOCAL begin radar 5277239 */ -/* This routine checks that type_decl is a class or class object followed by a '.' - which is an alternative syntax to class-method messaging [class-name class-method] -*/ - -static bool -cp_objc_property_reference_prefix (cp_parser *parser, tree type) -{ - return c_dialect_objc () && cp_lexer_peek_token (parser->lexer)->type == CPP_DOT - && (objc_is_id (type) || objc_is_class_name (type)); -} -/* APPLE LOCAL end radar 5277239 */ -/* APPLE LOCAL begin C* property (Radar 4436866, 4591909) */ -/* This routine parses the propery declarations. */ - -static void -objc_cp_parse_property_decl (cp_parser *parser) -{ - int declares_class_or_enum; - cp_decl_specifier_seq declspecs; - - cp_parser_decl_specifier_seq (parser, - CP_PARSER_FLAGS_NONE, - &declspecs, - &declares_class_or_enum); - /* Keep going until we hit the `;' at the end of the declaration. */ - while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - { - tree property; - cp_token *token; - cp_declarator *declarator - = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED, - NULL, NULL, false); - property = grokdeclarator (declarator, &declspecs, NORMAL,0, NULL); - /* Revover from any kind of error in property declaration. */ - if (property == error_mark_node || property == NULL_TREE) - return; - /* APPLE LOCAL begin objc new property */ - if (declspecs.attributes) - cplus_decl_attributes (&property, declspecs.attributes, 0); - /* APPLE LOCAL begin radar 4712415 */ - token = cp_lexer_peek_token (parser->lexer); - if (token->keyword == RID_ATTRIBUTE) - { - /* Attribute on the property itself. */ - declspecs.attributes = cp_parser_attributes_opt (parser); - cplus_decl_attributes (&property, declspecs.attributes, 0); - token = cp_lexer_peek_token (parser->lexer); - } - /* APPLE LOCAL end radar 4712415 */ - /* APPLE LOCAL end objc new property */ - /* Add to property list. */ - objc_add_property_variable (copy_node (property)); - if (token->type == CPP_COMMA) - { - cp_lexer_consume_token (parser->lexer); /* Eat ','. */ - continue; - } - else if (token->type == CPP_EOF) - return; - } - cp_lexer_consume_token (parser->lexer); /* Eat ';'. */ -} - -/* APPLE LOCAL begin objc new property */ -/* This routine parses @synthesize property_name[=ivar],... or - @dynamic paroperty_name,... syntax. -*/ -static void -objc_cp_parser_property_impl (cp_parser *parser, enum rid keyword) -{ - cp_lexer_consume_token (parser->lexer); /* Eat @synthesize or @dynamic */ - if (keyword == RID_AT_DYNAMIC) - { - tree identifier_list = cp_parser_objc_identifier_list (parser); - objc_declare_property_impl (2, identifier_list); - } - else - { - cp_token *sep = cp_lexer_peek_token (parser->lexer); - tree list = NULL_TREE; - do - { - tree property; - tree identifier_list; - if (sep->type == CPP_COMMA) - cp_lexer_consume_token (parser->lexer); /* Eat ',' */ - property = cp_parser_identifier (parser); - sep = cp_lexer_peek_token (parser->lexer); - if (sep->type == CPP_EQ) - { - cp_lexer_consume_token (parser->lexer); /* '=' */ - identifier_list = build_tree_list (cp_parser_identifier (parser), property); - } - else - identifier_list = build_tree_list (NULL_TREE, property); - list = chainon (list, identifier_list); - sep = cp_lexer_peek_token (parser->lexer); - } - while (sep->type == CPP_COMMA); - objc_declare_property_impl (1, list); - } - cp_parser_consume_semicolon_at_end_of_statement (parser); -} -/* APPLE LOCAL end objc new property */ - -/* This function parses a @property declaration inside an objective class - or its implementation. */ - -static void -objc_cp_parser_at_property (cp_parser *parser) -{ - cp_token *token; - - objc_set_property_attr (0, NULL_TREE); - /* Consume @property */ - cp_lexer_consume_token (parser->lexer); - token = cp_lexer_peek_token (parser->lexer); - if (token->type == CPP_OPEN_PAREN) - { - cp_lexer_consume_token (parser->lexer); - while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF) - { - tree node; - /* property has attribute list. */ - /* Consume '(' */ - node = cp_parser_identifier (parser); - if (node == ridpointers [(int) RID_READONLY]) - { - /* Do the readyonly thing. */ - objc_set_property_attr (1, NULL_TREE); - } - else if (node == ridpointers [(int) RID_GETTER] - || node == ridpointers [(int) RID_SETTER]) - { - /* Do the getter/setter attribute. */ - token = cp_lexer_consume_token (parser->lexer); - if (token->type == CPP_EQ) - { - /* APPLE LOCAL radar 4675792 */ - tree attr_ident = cp_parser_objc_selector (parser); - int num; - if (node == ridpointers [(int) RID_GETTER]) - num = 2; - else - { - num = 3; - /* Consume the ':' which must always follow the setter name. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COLON)) - cp_lexer_consume_token (parser->lexer); - } - objc_set_property_attr (num, attr_ident); - } - else - { - error ("getter/setter attribute must be followed by '='"); - break; - } - } - /* APPLE LOCAL begin objc new property */ - else if (node == ridpointers [(int) RID_READWRITE]) - { - objc_set_property_attr (9, NULL_TREE); - } - else if (node == ridpointers [(int) RID_ASSIGN]) - { - objc_set_property_attr (10, NULL_TREE); - } - else if (node == ridpointers [(int) RID_RETAIN]) - { - objc_set_property_attr (11, NULL_TREE); - } - else if (node == ridpointers [(int) RID_COPY]) - { - objc_set_property_attr (12, NULL_TREE); - } - /* APPLE LOCAL end objc new property */ - /* APPLE LOCAL begin radar 4947014 - objc atomic property */ - else if (node == ridpointers [(int) RID_NONATOMIC]) - { - objc_set_property_attr (13, NULL_TREE); - } - /* APPLE LOCAL end radar 4947014 - objc atomic property */ - else - { - error ("unknown property attribute"); - break; - } - /* APPLE LOCAL begin radar 6302949 */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA) - && cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN) - && cp_lexer_next_token_is_not (parser->lexer, CPP_EOF)) - warning (0, "property attributes must be separated by a comma"); - /* APPLE LOCAL end radar 6302949 */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) - cp_lexer_consume_token (parser->lexer); - token = cp_lexer_peek_token (parser->lexer); - } - if (token->type != CPP_CLOSE_PAREN) - { - error ("syntax error in @property's attribute declaration"); - } - /* Consume ')' */ - cp_lexer_consume_token (parser->lexer); - } - objc_cp_parse_property_decl (parser); -} -/* APPLE LOCAL end C* property (Radar 4436866, 4591909) */ - -/* 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. */ - -static void -cp_parser_consume_semicolon_at_end_of_statement (cp_parser *parser) -{ - /* Look for the trailing `;'. */ - if (!cp_parser_require (parser, CPP_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); - } -} - -/* Skip tokens until we have consumed an entire block, or until we - have consumed a non-nested `;'. */ - -static void -cp_parser_skip_to_end_of_block_or_statement (cp_parser* parser) -{ - int nesting_depth = 0; - - while (nesting_depth >= 0) - { - cp_token *token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_EOF: - case CPP_PRAGMA_EOL: - /* 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) - nesting_depth = -1; - break; - - case CPP_OPEN_BRACE: - /* Nest. */ - nesting_depth++; - break; - - default: - break; - } - - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - } -} - -/* Skip tokens until a non-nested closing curly brace is the next - token. */ - -static void -cp_parser_skip_to_closing_brace (cp_parser *parser) -{ - unsigned nesting_depth = 0; - - while (true) - { - cp_token *token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_EOF: - case CPP_PRAGMA_EOL: - /* If we've run out of tokens, stop. */ - return; - - 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; - 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); - } -} - -/* 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. */ - -static void -cp_parser_skip_to_pragma_eol (cp_parser* parser, cp_token *pragma_tok) -{ - cp_token *token; - - parser->lexer->in_pragma = false; - - do - token = cp_lexer_consume_token (parser->lexer); - while (token->type != CPP_PRAGMA_EOL && token->type != CPP_EOF); - - /* Ensure that the pragma is not parsed again. */ - cp_lexer_purge_tokens_after (parser->lexer, pragma_tok); -} - -/* Require pragma end of line, resyncing with it as necessary. The - arguments are as for cp_parser_skip_to_pragma_eol. */ - -static void -cp_parser_require_pragma_eol (cp_parser *parser, cp_token *pragma_tok) -{ - parser->lexer->in_pragma = false; - if (!cp_parser_require (parser, CPP_PRAGMA_EOL, "end of line")) - cp_parser_skip_to_pragma_eol (parser, pragma_tok); -} - -/* 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. */ - -static tree -cp_parser_make_typename_type (cp_parser *parser, tree scope, tree id) -{ - tree result; - if (TREE_CODE (id) == IDENTIFIER_NODE) - { - result = make_typename_type (scope, id, typename_type, - /*complain=*/tf_none); - if (result == error_mark_node) - cp_parser_diagnose_invalid_type_name (parser, scope, id); - return result; - } - return make_typename_type (scope, id, typename_type, tf_error); -} - - -/* Create a new C++ parser. */ - -static cp_parser * -cp_parser_new (void) -{ - cp_parser *parser; - cp_lexer *lexer; - unsigned i; - - /* cp_lexer_new_main is called before calling ggc_alloc because - cp_lexer_new_main might load a PCH file. */ - lexer = cp_lexer_new_main (); - - /* Initialize the binops_by_token so that we can get the tree - directly from the token. */ - for (i = 0; i < sizeof (binops) / sizeof (binops[0]); i++) - binops_by_token[binops[i].token_type] = binops[i]; - - parser = GGC_CNEW (cp_parser); - parser->lexer = lexer; - parser->context = cp_parser_context_new (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 = false; - - /* 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; - - /* Declarations aren't implicitly extern "C". */ - parser->implicit_extern_c = 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; - - /* The unparsed function queue is empty. */ - parser->unparsed_functions_queues = build_tree_list (NULL_TREE, NULL_TREE); - - /* There are no classes being defined. */ - parser->num_classes_being_defined = 0; - - /* No template parameters apply. */ - parser->num_template_parameter_lists = 0; - - return parser; -} - -/* 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. */ -static void -cp_parser_push_lexer_for_tokens (cp_parser *parser, cp_token_cache *cache) -{ - 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); -} - -/* 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. */ -static void -cp_parser_pop_lexer (cp_parser *parser) -{ - 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); -} - -/* Lexical conventions [gram.lex] */ - -/* Parse an identifier. Returns an IDENTIFIER_NODE representing the - identifier. */ - -static tree -cp_parser_identifier (cp_parser* parser) -{ - cp_token *token; - - /* Look for the identifier. */ - token = cp_parser_require (parser, CPP_NAME, "identifier"); - /* Return the value. */ - return token ? token->u.value : error_mark_node; -} - -/* 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. */ -static tree -cp_parser_string_literal (cp_parser *parser, bool translate, bool wide_ok) -{ - tree value; - bool wide = false; - /* APPLE LOCAL pascal strings */ - bool pascal_p = false; - size_t count; - struct obstack str_ob; - cpp_string str, istr, *strs; - cp_token *tok; - - tok = cp_lexer_peek_token (parser->lexer); - if (!cp_parser_is_string_literal (tok)) - { - cp_parser_error (parser, "expected string-literal"); - return error_mark_node; - } - - /* 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 (tok->u.value); - str.len = TREE_STRING_LENGTH (tok->u.value); - count = 1; - if (tok->type == CPP_WSTRING) - wide = true; - /* APPLE LOCAL begin pascal strings */ - if (CPP_OPTION (parse_in, pascal_strings)) - { - if (wide && str.text[0] == 'L' && str.text[2] == '\\' && str.text[3] == 'p') - pascal_p = true; - else if (str.text[1] == '\\' && str.text[2] == 'p') - pascal_p = true; - } - /* APPLE LOCAL end pascal strings */ - - strs = &str; - } - else - { - gcc_obstack_init (&str_ob); - count = 0; - - do - { - cp_lexer_consume_token (parser->lexer); - count++; - str.text = (unsigned char *)TREE_STRING_POINTER (tok->u.value); - str.len = TREE_STRING_LENGTH (tok->u.value); - if (tok->type == CPP_WSTRING) - wide = true; - /* APPLE LOCAL begin pascal strings */ - if (CPP_OPTION (parse_in, pascal_strings) && count == 1) - { - if (wide && str.text[0] == 'L' && str.text[2] == '\\' && str.text[3] == 'p') - pascal_p = true; - else if (str.text[1] == '\\' && str.text[2] == 'p') - pascal_p = true; - } - /* APPLE LOCAL end pascal strings */ - - obstack_grow (&str_ob, &str, sizeof (cpp_string)); - - tok = cp_lexer_peek_token (parser->lexer); - } - while (cp_parser_is_string_literal (tok)); - - strs = (cpp_string *) obstack_finish (&str_ob); - } - - if (wide && !wide_ok) - { - cp_parser_error (parser, "a wide string is invalid in this context"); - wide = false; - } - - if ((translate ? cpp_interpret_string : cpp_interpret_string_notranslate) - /* APPLE LOCAL pascal strings */ - (parse_in, strs, count, &istr, wide, pascal_p)) - { - value = build_string (istr.len, (char *)istr.text); - free ((void *)istr.text); - - /* APPLE LOCAL begin pascal strings */ - TREE_TYPE (value) = wide ? wchar_array_type_node - : pascal_p ? pascal_string_type_node - : char_array_type_node; - /* APPLE LOCAL end pascal strings */ - value = fix_string_type (value); - } - else - /* cpp_interpret_string has issued an error. */ - value = error_mark_node; - - if (count > 1) - obstack_free (&str_ob, 0); - - return value; -} - - -/* Basic concepts [gram.basic] */ - -/* Parse a translation-unit. - - translation-unit: - declaration-seq [opt] - - Returns TRUE if all went well. */ - -static bool -cp_parser_translation_unit (cp_parser* parser) -{ - /* The address of the first non-permanent object on the declarator - obstack. */ - static void *declarator_obstack_base; - - bool success; - - /* Create the declarator obstack, if necessary. */ - if (!cp_error_declarator) - { - gcc_obstack_init (&declarator_obstack); - /* Create the error declarator. */ - cp_error_declarator = make_declarator (cdk_error); - /* Create the empty parameter list. */ - no_parameters = make_parameter_declarator (NULL, NULL, NULL_TREE); - /* Remember where the base of the declarator obstack lies. */ - declarator_obstack_base = obstack_next_free (&declarator_obstack); - } - - cp_parser_declaration_seq_opt (parser); - - /* If there are no tokens left then all went well. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_EOF)) - { - /* Get rid of the token array; we don't need it any more. */ - cp_lexer_destroy (parser->lexer); - parser->lexer = NULL; - - /* This file might have been a context that's implicitly extern - "C". If so, pop the lang context. (Only relevant for PCH.) */ - if (parser->implicit_extern_c) - { - pop_lang_context (); - parser->implicit_extern_c = false; - } - - /* Finish up. */ - finish_translation_unit (); - - success = true; - } - else - { - cp_parser_error (parser, "expected declaration"); - success = false; - } - - /* Make sure the declarator obstack was fully cleaned up. */ - gcc_assert (obstack_next_free (&declarator_obstack) - == declarator_obstack_base); - - /* All went well. */ - return success; -} - -/* Expressions [gram.expr] */ - -/* Parse a primary-expression. - - primary-expression: - literal - this - ( expression ) - id-expression - - GNU Extensions: - - primary-expression: - ( compound-statement ) - __builtin_va_arg ( assignment-expression , type-id ) - __builtin_offsetof ( type-id , offsetof-expression ) - APPLE LOCAL blocks 6040305 (cf) - block-literal-expr - - 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. */ - -static tree -cp_parser_primary_expression (cp_parser *parser, - bool address_p, - bool cast_p, - bool template_arg_p, - cp_id_kind *idk) -{ - cp_token *token; - /* APPLE LOCAL CW asm blocks */ - int atsignhack = 0; - - /* 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 (token->type) - { - /* APPLE LOCAL begin blocks 6040305 (cf) */ - case CPP_XOR: - if (flag_blocks) - { - tree expr = cp_parser_block_literal_expr (parser); - return expr; - } - cp_parser_error (parser, "expected primary-expression"); - return error_mark_node; - /* APPLE LOCAL end blocks 6040305 (cf) */ - /* literal: - integer-literal - character-literal - floating-literal - string-literal - boolean-literal */ - case CPP_CHAR: - case CPP_WCHAR: - case CPP_NUMBER: - token = cp_lexer_consume_token (parser->lexer); - /* 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) == REAL_CST - && parser->integral_constant_expression_p - && 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)) - 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, "floating-point literal"); - } - return token->u.value; - - case CPP_STRING: - case CPP_WSTRING: - /* ??? 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); - - case CPP_OPEN_PAREN: - { - tree expr; - bool saved_greater_than_is_operator_p; - - /* Consume the `('. */ - cp_lexer_consume_token (parser->lexer); - /* 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 we see `( { ' then we are looking at the beginning of - a GNU statement-expression. */ - if (cp_parser_allow_gnu_extensions_p (parser) - && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) - { - /* Statement-expressions are not allowed by the standard. */ - if (pedantic) - pedwarn ("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) - error ("statement-expressions are allowed only inside functions"); - /* Start the statement-expression. */ - expr = begin_stmt_expr (); - /* Parse the compound-statement. */ - /* APPLE LOCAL radar 5982990 */ - cp_parser_compound_statement (parser, expr, false, false); - /* Finish up. */ - expr = finish_stmt_expr (expr, false); - } - else - { - /* Parse the parenthesized expression. */ - expr = cp_parser_expression (parser, cast_p); - /* 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. */ - finish_parenthesized_expr (expr); - } - /* 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 `)'. */ - if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - cp_parser_skip_to_end_of_statement (parser); - - return expr; - } - - case CPP_KEYWORD: - switch (token->keyword) - { - /* These two are the boolean literals. */ - case RID_TRUE: - cp_lexer_consume_token (parser->lexer); - return boolean_true_node; - case RID_FALSE: - cp_lexer_consume_token (parser->lexer); - return boolean_false_node; - - /* The `__null' literal. */ - case RID_NULL: - cp_lexer_consume_token (parser->lexer); - return null_node; - - /* Recognize the `this' keyword. */ - case RID_THIS: - cp_lexer_consume_token (parser->lexer); - if (parser->local_variables_forbidden_p) - { - error ("%<this%> may not be used in this context"); - return error_mark_node; - } - /* Pointers cannot appear in constant-expressions. */ - if (cp_parser_non_integral_constant_expression (parser, - "`this'")) - return error_mark_node; - return finish_this_expr (); - - /* 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: - /* 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); - /* Look up the name. */ - return finish_fname (token->u.value); - - case RID_VA_ARG: - { - tree expression; - tree type; - - /* 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 `('. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - /* Now, parse the assignment-expression. */ - expression = cp_parser_assignment_expression (parser, - /*cast_p=*/false); - /* Look for the `,'. */ - cp_parser_require (parser, CPP_COMMA, "`,'"); - /* Parse the type-id. */ - type = cp_parser_type_id (parser); - /* Look for the closing `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - /* Using `va_arg' in a constant-expression is not - allowed. */ - if (cp_parser_non_integral_constant_expression (parser, - "`va_arg'")) - return error_mark_node; - return build_x_va_arg (expression, type); - } - - case RID_OFFSETOF: - return cp_parser_builtin_offsetof (parser); - - /* Objective-C++ expressions. */ - case RID_AT_ENCODE: - case RID_AT_PROTOCOL: - case RID_AT_SELECTOR: - return cp_parser_objc_expression (parser); - - default: - cp_parser_error (parser, "expected primary-expression"); - return error_mark_node; - } - - /* APPLE LOCAL begin CW asm blocks */ - case CPP_ATSIGN: - /* Recognize @-labels and handle them specially later. */ - cp_lexer_consume_token (parser->lexer); - atsignhack = 1; - token = cp_lexer_peek_token (parser->lexer); - /* APPLE LOCAL end CW asm blocks */ - - /* 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: - case CPP_NESTED_NAME_SPECIFIER: - { - tree id_expression; - tree decl; - const char *error_msg; - bool template_p; - bool done; - - id_expression: - /* 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); - /* APPLE LOCAL begin CW asm blocks */ - /* Replace the id with an id prefixed with @. */ - if (atsignhack && id_expression != error_mark_node) - id_expression = prepend_char_identifier (id_expression, '@'); - /* APPLE LOCAL end CW asm blocks */ - if (id_expression == error_mark_node) - return error_mark_node; - 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) == TEMPLATE_ID_EXPR - || TREE_CODE (id_expression) == TYPE_DECL) - decl = id_expression; - /* Look up the name. */ - else - { - tree ambiguous_decls; - - decl = cp_parser_lookup_name (parser, id_expression, - none_type, - template_p, - /*is_namespace=*/false, - /*check_dependency=*/true, - &ambiguous_decls); - /* If the lookup was ambiguous, an error will already have - been issued. */ - if (ambiguous_decls) - return error_mark_node; - - /* APPLE LOCAL begin radar 5277239 */ - if (TREE_CODE (decl) == TYPE_DECL - && cp_objc_property_reference_prefix (parser, TREE_TYPE (decl))) - return cp_parser_objc_reference_expression (parser, decl); - /* APPLE LOCAL end radar 5277239 */ - /* In Objective-C++, an instance variable (ivar) may be preferred - to whatever cp_parser_lookup_name() found. */ - decl = objc_lookup_ivar (decl, id_expression); - - /* If name lookup gives us a SCOPE_REF, then the - qualifying scope was dependent. */ - if (TREE_CODE (decl) == 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_variable_p (decl)) - { - /* It might be that we only found DECL because we are - trying to be generous with pre-ISO scoping rules. - For example, consider: - - int i; - void g() { - for (int i = 0; i < 10; ++i) {} - extern void f(int j = i); - } - - Here, name look up will originally find the out - of scope `i'. We need to issue a warning message, - but then use the global `i'. */ - decl = check_for_out_of_scope_variable (decl); - if (local_variable_p (decl)) - { - error ("local variable %qD may not appear in this context", - decl); - return error_mark_node; - } - } - } - - 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)); - if (error_msg) - cp_parser_error (parser, error_msg); - return decl; - } - - /* Anything else is an error. */ - default: - /* APPLE LOCAL begin CW asm blocks */ - if (inside_iasm_block) - { - if (token->type == CPP_OPEN_SQUARE) - { - tree expr; - cp_lexer_consume_token (parser->lexer); - expr = cp_parser_iasm_operand (parser); - cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"); - return iasm_build_bracket (expr, NULL_TREE); - } - } - /* APPLE LOCAL end CW asm blocks */ - - /* ...unless we have an Objective-C++ message or string literal, that is. */ - if (c_dialect_objc () - && (token->type == CPP_OPEN_SQUARE || token->type == CPP_OBJC_STRING)) - return cp_parser_objc_expression (parser); - - cp_parser_error (parser, "expected primary-expression"); - return error_mark_node; - } -} - -/* 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. */ - -static tree -cp_parser_id_expression (cp_parser *parser, - bool template_keyword_p, - bool check_dependency_p, - bool *template_p, - bool declarator_p, - bool optional_p) -{ - 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 - = (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false) - != NULL_TREE); - /* 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) - != NULL_TREE); - /* 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; - tree unqualified_id; - bool is_template; - - /* See if the next token is the `template' keyword. */ - if (!template_p) - template_p = &is_template; - *template_p = cp_parser_optional_template_keyword (parser); - /* Name lookup we do during the processing of the - unqualified-id might obliterate SCOPE. */ - saved_scope = parser->scope; - saved_object_scope = parser->object_scope; - saved_qualifying_scope = parser->qualifying_scope; - /* Process the final unqualified-id. */ - unqualified_id = cp_parser_unqualified_id (parser, *template_p, - check_dependency_p, - declarator_p, - /*optional_p=*/false); - /* Restore the SAVED_SCOPE for our caller. */ - parser->scope = saved_scope; - parser->object_scope = saved_object_scope; - parser->qualifying_scope = saved_qualifying_scope; - - return unqualified_id; - } - /* Otherwise, if we are in global scope, then we are looking at one - of the other qualified-id productions. */ - else if (global_scope_p) - { - cp_token *token; - tree id; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - - /* If it's an identifier, and the next token is not a "<", then - we can avoid the template-id case. This is an optimization - for this common case. */ - if (token->type == CPP_NAME - && !cp_parser_nth_token_starts_template_argument_list_p - (parser, 2)) - return cp_parser_identifier (parser); - - cp_parser_parse_tentatively (parser); - /* Try a template-id. */ - id = cp_parser_template_id (parser, - /*template_keyword_p=*/false, - /*check_dependency_p=*/true, - declarator_p); - /* If that worked, we're done. */ - if (cp_parser_parse_definitely (parser)) - return id; - - /* Peek at the next token. (Changes in the token buffer may - have invalidated the pointer obtained above.) */ - token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_NAME: - return cp_parser_identifier (parser); - - case CPP_KEYWORD: - if (token->keyword == RID_OPERATOR) - return cp_parser_operator_function_id (parser); - /* Fall through. */ - - default: - cp_parser_error (parser, "expected id-expression"); - return error_mark_node; - } - } - else - return cp_parser_unqualified_id (parser, template_keyword_p, - /*check_dependency_p=*/true, - declarator_p, - optional_p); -} - -/* Parse an unqualified-id. - - unqualified-id: - identifier - operator-function-id - conversion-function-id - ~ class-name - template-id - - If TEMPLATE_KEYWORD_P is TRUE, we have just seen the `template' - keyword, in a construct like `A::template ...'. - - Returns a representation of unqualified-id. For the `identifier' - production, an IDENTIFIER_NODE is returned. For the `~ class-name' - production a BIT_NOT_EXPR is returned; the operand of the - BIT_NOT_EXPR is an IDENTIFIER_NODE for the class-name. For the - other productions, see the documentation accompanying the - corresponding parsing functions. If CHECK_DEPENDENCY_P is false, - names are looked up in uninstantiated templates. If DECLARATOR_P - is true, the unqualified-id is appearing as part of a declarator, - rather than as part of an expression. */ - -static tree -cp_parser_unqualified_id (cp_parser* parser, - bool template_keyword_p, - bool check_dependency_p, - bool declarator_p, - bool optional_p) -{ - cp_token *token; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_NAME: - { - tree id; - - /* We don't know yet whether or not this will be a - template-id. */ - cp_parser_parse_tentatively (parser); - /* Try a template-id. */ - id = cp_parser_template_id (parser, template_keyword_p, - check_dependency_p, - declarator_p); - /* If it worked, we're done. */ - if (cp_parser_parse_definitely (parser)) - return id; - /* Otherwise, it's an ordinary identifier. */ - return cp_parser_identifier (parser); - } - - case CPP_TEMPLATE_ID: - return cp_parser_template_id (parser, template_keyword_p, - check_dependency_p, - declarator_p); - - case CPP_COMPL: - { - tree type_decl; - tree qualifying_scope; - tree object_scope; - tree scope; - bool done; - - /* Consume the `~' token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the class-name. The standard, as written, seems to - say that: - - template <typename T> struct S { ~S (); }; - template <typename T> S<T>::~S() {} - - is invalid, since `~' must be followed by a class-name, but - `S<T>' is dependent, and so not known to be a class. - That's not right; we need to look in uninstantiated - templates. A further complication arises from: - - template <typename T> void f(T t) { - t.T::~T(); - } - - Here, it is not possible to look up `T' in the scope of `T' - itself. We must look in both the current scope, and the - scope of the containing complete expression. - - Yet another issue is: - - struct S { - int S; - ~S(); - }; - - S::~S() {} - - The standard does not seem to say that the `S' in `~S' - should refer to the type `S' and not the data member - `S::S'. */ - - /* DR 244 says that we look up the name after the "~" in the - same scope as we looked up the qualifying name. That idea - isn't fully worked out; it's more complicated than that. */ - scope = parser->scope; - object_scope = parser->object_scope; - qualifying_scope = parser->qualifying_scope; - - /* Check for invalid scopes. */ - if (scope == error_mark_node) - { - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - cp_lexer_consume_token (parser->lexer); - return error_mark_node; - } - if (scope && TREE_CODE (scope) == NAMESPACE_DECL) - { - if (!cp_parser_uncommitted_to_tentative_parse_p (parser)) - error ("scope %qT before %<~%> is not a class-name", scope); - cp_parser_simulate_error (parser); - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - cp_lexer_consume_token (parser->lexer); - return error_mark_node; - } - gcc_assert (!scope || TYPE_P (scope)); - - /* If the name is of the form "X::~X" it's OK. */ - token = cp_lexer_peek_token (parser->lexer); - if (scope - && token->type == CPP_NAME - && (cp_lexer_peek_nth_token (parser->lexer, 2)->type - == CPP_OPEN_PAREN) - && constructor_name_p (token->u.value, scope)) - { - cp_lexer_consume_token (parser->lexer); - return build_nt (BIT_NOT_EXPR, scope); - } - - /* If there was an explicit qualification (S::~T), first look - in the scope given by the qualification (i.e., S). */ - done = false; - type_decl = NULL_TREE; - if (scope) - { - cp_parser_parse_tentatively (parser); - type_decl = cp_parser_class_name (parser, - /*typename_keyword_p=*/false, - /*template_keyword_p=*/false, - none_type, - /*check_dependency=*/false, - /*class_head_p=*/false, - declarator_p); - if (cp_parser_parse_definitely (parser)) - done = true; - } - /* In "N::S::~S", look in "N" as well. */ - if (!done && scope && qualifying_scope) - { - cp_parser_parse_tentatively (parser); - parser->scope = qualifying_scope; - parser->object_scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - type_decl - = cp_parser_class_name (parser, - /*typename_keyword_p=*/false, - /*template_keyword_p=*/false, - none_type, - /*check_dependency=*/false, - /*class_head_p=*/false, - declarator_p); - if (cp_parser_parse_definitely (parser)) - done = true; - } - /* In "p->S::~T", look in the scope given by "*p" as well. */ - else if (!done && object_scope) - { - cp_parser_parse_tentatively (parser); - parser->scope = object_scope; - parser->object_scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - type_decl - = cp_parser_class_name (parser, - /*typename_keyword_p=*/false, - /*template_keyword_p=*/false, - none_type, - /*check_dependency=*/false, - /*class_head_p=*/false, - declarator_p); - if (cp_parser_parse_definitely (parser)) - done = true; - } - /* Look in the surrounding context. */ - if (!done) - { - parser->scope = NULL_TREE; - parser->object_scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - type_decl - = cp_parser_class_name (parser, - /*typename_keyword_p=*/false, - /*template_keyword_p=*/false, - none_type, - /*check_dependency=*/false, - /*class_head_p=*/false, - declarator_p); - } - /* If an error occurred, assume that the name of the - destructor is the same as the name of the qualifying - class. That allows us to keep parsing after running - into ill-formed destructor names. */ - if (type_decl == error_mark_node && scope) - return build_nt (BIT_NOT_EXPR, scope); - else if (type_decl == error_mark_node) - return error_mark_node; - - /* Check that destructor name and scope match. */ - if (declarator_p && scope && !check_dtor_name (scope, type_decl)) - { - if (!cp_parser_uncommitted_to_tentative_parse_p (parser)) - error ("declaration of %<~%T%> as member of %qT", - type_decl, scope); - cp_parser_simulate_error (parser); - return error_mark_node; - } - - /* [class.dtor] - - A typedef-name that names a class shall not be used as the - identifier in the declarator for a destructor declaration. */ - if (declarator_p - && !DECL_IMPLICIT_TYPEDEF_P (type_decl) - && !DECL_SELF_REFERENCE_P (type_decl) - && !cp_parser_uncommitted_to_tentative_parse_p (parser)) - error ("typedef-name %qD used as destructor declarator", - type_decl); - - return build_nt (BIT_NOT_EXPR, TREE_TYPE (type_decl)); - } - - /* APPLE LOCAL begin CW asm blocks C++ */ - case CPP_NUMBER: - { - if (flag_iasm_blocks && inside_iasm_block - && TREE_CODE (token->u.value) == INTEGER_CST) - { - char buf[60]; - - sprintf (buf, HOST_WIDE_INT_PRINT_UNSIGNED, tree_low_cst (token->u.value, 0)); - cp_lexer_consume_token (parser->lexer); - return get_identifier (buf); - } - goto bad; - } - /* APPLE LOCAL end CW asm blocks C++ */ - - case CPP_KEYWORD: - if (token->keyword == RID_OPERATOR) - { - tree id; - - /* This could be a template-id, so we try that first. */ - cp_parser_parse_tentatively (parser); - /* Try a template-id. */ - id = cp_parser_template_id (parser, template_keyword_p, - /*check_dependency_p=*/true, - declarator_p); - /* If that worked, we're done. */ - if (cp_parser_parse_definitely (parser)) - return id; - /* We still don't know whether we're looking at an - operator-function-id or a conversion-function-id. */ - cp_parser_parse_tentatively (parser); - /* Try an operator-function-id. */ - id = cp_parser_operator_function_id (parser); - /* If that didn't work, try a conversion-function-id. */ - if (!cp_parser_parse_definitely (parser)) - id = cp_parser_conversion_function_id (parser); - - return id; - } - /* Fall through. */ - - default: - if (optional_p) - return NULL_TREE; - /* APPLE LOCAL CW asm blocks C++ */ - bad: - cp_parser_error (parser, "expected unqualified-id"); - return error_mark_node; - } -} - -/* Parse an (optional) nested-name-specifier. - - nested-name-specifier: - class-or-namespace-name :: nested-name-specifier [opt] - class-or-namespace-name :: template nested-name-specifier [opt] - - PARSER->SCOPE should be set appropriately before this function is - called. TYPENAME_KEYWORD_P is TRUE if the `typename' keyword is in - effect. TYPE_P is TRUE if we non-type bindings should be ignored - in name lookups. - - Sets PARSER->SCOPE to the class (TYPE) or namespace - (NAMESPACE_DECL) specified by the nested-name-specifier, or leaves - it unchanged if there is no nested-name-specifier. Returns the new - scope iff there is a nested-name-specifier, or NULL_TREE otherwise. - - If IS_DECLARATION is TRUE, the nested-name-specifier is known to be - part of a declaration and/or decl-specifier. */ - -static tree -cp_parser_nested_name_specifier_opt (cp_parser *parser, - bool typename_keyword_p, - bool check_dependency_p, - bool type_p, - bool is_declaration) -{ - bool success = false; - cp_token_position start = 0; - cp_token *token; - - /* Remember where the nested-name-specifier starts. */ - if (cp_parser_uncommitted_to_tentative_parse_p (parser)) - { - start = cp_lexer_token_position (parser->lexer, false); - push_deferring_access_checks (dk_deferred); - } - - while (true) - { - tree new_scope; - tree old_scope; - tree saved_qualifying_scope; - bool template_keyword_p; - - /* Spot cases that cannot be the beginning of a - nested-name-specifier. */ - token = cp_lexer_peek_token (parser->lexer); - - /* If the next token is CPP_NESTED_NAME_SPECIFIER, just process - the already parsed nested-name-specifier. */ - if (token->type == CPP_NESTED_NAME_SPECIFIER) - { - /* Grab the nested-name-specifier and continue the loop. */ - cp_parser_pre_parsed_nested_name_specifier (parser); - /* If we originally encountered this nested-name-specifier - with IS_DECLARATION set to false, we will not have - resolved TYPENAME_TYPEs, so we must do so here. */ - if (is_declaration - && TREE_CODE (parser->scope) == TYPENAME_TYPE) - { - new_scope = resolve_typename_type (parser->scope, - /*only_current_p=*/false); - if (new_scope != error_mark_node) - parser->scope = new_scope; - } - success = true; - continue; - } - - /* Spot cases that cannot be the beginning of a - nested-name-specifier. On the second and subsequent times - through the loop, we look for the `template' keyword. */ - if (success && token->keyword == RID_TEMPLATE) - ; - /* A template-id can start a nested-name-specifier. */ - else if (token->type == CPP_TEMPLATE_ID) - ; - else - { - /* If the next token is not an identifier, then it is - definitely not a class-or-namespace-name. */ - if (token->type != CPP_NAME) - break; - /* If the following token is neither a `<' (to begin a - template-id), nor a `::', then we are not looking at a - nested-name-specifier. */ - token = cp_lexer_peek_nth_token (parser->lexer, 2); - if (token->type != CPP_SCOPE - && !cp_parser_nth_token_starts_template_argument_list_p - (parser, 2)) - break; - } - - /* The nested-name-specifier is optional, so we parse - tentatively. */ - cp_parser_parse_tentatively (parser); - - /* Look for the optional `template' keyword, if this isn't the - first time through the loop. */ - if (success) - template_keyword_p = cp_parser_optional_template_keyword (parser); - else - template_keyword_p = false; - - /* Save the old scope since the name lookup we are about to do - might destroy it. */ - old_scope = parser->scope; - saved_qualifying_scope = parser->qualifying_scope; - /* In a declarator-id like "X<T>::I::Y<T>" we must be able to - look up names in "X<T>::I" in order to determine that "Y" is - a template. So, if we have a typename at this point, we make - an effort to look through it. */ - if (is_declaration - && !typename_keyword_p - && parser->scope - && TREE_CODE (parser->scope) == TYPENAME_TYPE) - parser->scope = resolve_typename_type (parser->scope, - /*only_current_p=*/false); - /* Parse the qualifying entity. */ - new_scope - = cp_parser_class_or_namespace_name (parser, - typename_keyword_p, - template_keyword_p, - check_dependency_p, - type_p, - is_declaration); - /* Look for the `::' token. */ - cp_parser_require (parser, CPP_SCOPE, "`::'"); - - /* If we found what we wanted, we keep going; otherwise, we're - done. */ - if (!cp_parser_parse_definitely (parser)) - { - bool error_p = false; - - /* Restore the OLD_SCOPE since it was valid before the - failed attempt at finding the last - class-or-namespace-name. */ - parser->scope = old_scope; - parser->qualifying_scope = saved_qualifying_scope; - if (cp_parser_uncommitted_to_tentative_parse_p (parser)) - break; - /* If the next token is an identifier, and the one after - that is a `::', then any valid interpretation would have - found a class-or-namespace-name. */ - while (cp_lexer_next_token_is (parser->lexer, CPP_NAME) - && (cp_lexer_peek_nth_token (parser->lexer, 2)->type - == CPP_SCOPE) - && (cp_lexer_peek_nth_token (parser->lexer, 3)->type - != CPP_COMPL)) - { - token = cp_lexer_consume_token (parser->lexer); - if (!error_p) - { - if (!token->ambiguous_p) - { - tree decl; - tree ambiguous_decls; - - decl = cp_parser_lookup_name (parser, token->u.value, - none_type, - /*is_template=*/false, - /*is_namespace=*/false, - /*check_dependency=*/true, - &ambiguous_decls); - if (TREE_CODE (decl) == TEMPLATE_DECL) - error ("%qD used without template parameters", decl); - else if (ambiguous_decls) - { - error ("reference to %qD is ambiguous", - token->u.value); - print_candidates (ambiguous_decls); - decl = error_mark_node; - } - else - cp_parser_name_lookup_error - (parser, token->u.value, decl, - "is not a class or namespace"); - } - parser->scope = error_mark_node; - error_p = true; - /* Treat this as a successful nested-name-specifier - due to: - - [basic.lookup.qual] - - If the name found is not a class-name (clause - _class_) or namespace-name (_namespace.def_), the - program is ill-formed. */ - success = true; - } - cp_lexer_consume_token (parser->lexer); - } - break; - } - /* We've found one valid nested-name-specifier. */ - success = true; - /* Name lookup always gives us a DECL. */ - if (TREE_CODE (new_scope) == TYPE_DECL) - new_scope = TREE_TYPE (new_scope); - /* Uses of "template" must be followed by actual templates. */ - if (template_keyword_p - && !(CLASS_TYPE_P (new_scope) - && ((CLASSTYPE_USE_TEMPLATE (new_scope) - && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (new_scope))) - || CLASSTYPE_IS_TEMPLATE (new_scope))) - && !(TREE_CODE (new_scope) == TYPENAME_TYPE - && (TREE_CODE (TYPENAME_TYPE_FULLNAME (new_scope)) - == TEMPLATE_ID_EXPR))) - pedwarn (TYPE_P (new_scope) - ? "%qT is not a template" - : "%qD is not a template", - new_scope); - /* If it is a class scope, try to complete it; we are about to - be looking up names inside the class. */ - if (TYPE_P (new_scope) - /* Since checking types for dependency can be expensive, - avoid doing it if the type is already complete. */ - && !COMPLETE_TYPE_P (new_scope) - /* Do not try to complete dependent types. */ - && !dependent_type_p (new_scope)) - new_scope = complete_type (new_scope); - /* Make sure we look in the right scope the next time through - the loop. */ - parser->scope = new_scope; - } - - /* If parsing tentatively, replace the sequence of tokens that makes - up the nested-name-specifier with a CPP_NESTED_NAME_SPECIFIER - token. That way, should we re-parse the token stream, we will - not have to repeat the effort required to do the parse, nor will - we issue duplicate error messages. */ - if (success && start) - { - cp_token *token; - - token = cp_lexer_token_at (parser->lexer, start); - /* Reset the contents of the START token. */ - token->type = CPP_NESTED_NAME_SPECIFIER; - /* Retrieve any deferred checks. Do not pop this access checks yet - so the memory will not be reclaimed during token replacing below. */ - token->u.tree_check_value = GGC_CNEW (struct tree_check); - token->u.tree_check_value->value = parser->scope; - token->u.tree_check_value->checks = get_deferred_access_checks (); - token->u.tree_check_value->qualifying_scope = - parser->qualifying_scope; - token->keyword = RID_MAX; - - /* Purge all subsequent tokens. */ - cp_lexer_purge_tokens_after (parser->lexer, start); - } - - if (start) - pop_to_parent_deferring_access_checks (); - - return success ? parser->scope : NULL_TREE; -} - -/* Parse a nested-name-specifier. See - cp_parser_nested_name_specifier_opt for details. This function - behaves identically, except that it will an issue an error if no - nested-name-specifier is present. */ - -static tree -cp_parser_nested_name_specifier (cp_parser *parser, - bool typename_keyword_p, - bool check_dependency_p, - bool type_p, - bool is_declaration) -{ - tree scope; - - /* Look for the nested-name-specifier. */ - scope = cp_parser_nested_name_specifier_opt (parser, - typename_keyword_p, - check_dependency_p, - type_p, - is_declaration); - /* If it was not present, issue an error message. */ - if (!scope) - { - cp_parser_error (parser, "expected nested-name-specifier"); - parser->scope = NULL_TREE; - } - - return scope; -} - -/* Parse a class-or-namespace-name. - - class-or-namespace-name: - class-name - namespace-name - - TYPENAME_KEYWORD_P is TRUE iff the `typename' keyword is in effect. - TEMPLATE_KEYWORD_P is TRUE iff the `template' keyword is in effect. - CHECK_DEPENDENCY_P is FALSE iff dependent names should be looked up. - TYPE_P is TRUE iff the next name should be taken as a class-name, - even the same name is declared to be another entity in the same - scope. - - Returns the class (TYPE_DECL) or namespace (NAMESPACE_DECL) - specified by the class-or-namespace-name. If neither is found the - ERROR_MARK_NODE is returned. */ - -static tree -cp_parser_class_or_namespace_name (cp_parser *parser, - bool typename_keyword_p, - bool template_keyword_p, - bool check_dependency_p, - bool type_p, - bool is_declaration) -{ - tree saved_scope; - tree saved_qualifying_scope; - tree saved_object_scope; - tree scope; - bool only_class_p; - - /* Before we try to parse the class-name, we must save away the - current PARSER->SCOPE since cp_parser_class_name will destroy - it. */ - saved_scope = parser->scope; - saved_qualifying_scope = parser->qualifying_scope; - saved_object_scope = parser->object_scope; - /* Try for a class-name first. If the SAVED_SCOPE is a type, then - there is no need to look for a namespace-name. */ - only_class_p = template_keyword_p || (saved_scope && TYPE_P (saved_scope)); - if (!only_class_p) - cp_parser_parse_tentatively (parser); - scope = cp_parser_class_name (parser, - typename_keyword_p, - template_keyword_p, - type_p ? class_type : none_type, - check_dependency_p, - /*class_head_p=*/false, - is_declaration); - /* If that didn't work, try for a namespace-name. */ - if (!only_class_p && !cp_parser_parse_definitely (parser)) - { - /* Restore the saved scope. */ - parser->scope = saved_scope; - parser->qualifying_scope = saved_qualifying_scope; - parser->object_scope = saved_object_scope; - /* If we are not looking at an identifier followed by the scope - resolution operator, then this is not part of a - nested-name-specifier. (Note that this function is only used - to parse the components of a nested-name-specifier.) */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME) - || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_SCOPE) - return error_mark_node; - scope = cp_parser_namespace_name (parser); - } - - return scope; -} - -/* Parse a postfix-expression. - - postfix-expression: - primary-expression - postfix-expression [ expression ] - postfix-expression ( expression-list [opt] ) - simple-type-specifier ( expression-list [opt] ) - typename :: [opt] nested-name-specifier identifier - ( expression-list [opt] ) - typename :: [opt] nested-name-specifier template [opt] template-id - ( expression-list [opt] ) - postfix-expression . template [opt] id-expression - postfix-expression -> template [opt] id-expression - postfix-expression . pseudo-destructor-name - postfix-expression -> pseudo-destructor-name - postfix-expression ++ - postfix-expression -- - dynamic_cast < type-id > ( expression ) - static_cast < type-id > ( expression ) - reinterpret_cast < type-id > ( expression ) - const_cast < type-id > ( expression ) - typeid ( expression ) - typeid ( type-id ) - - GNU Extension: - - postfix-expression: - ( type-id ) { initializer-list , [opt] } - - This extension is a GNU version of the C99 compound-literal - construct. (The C99 grammar uses `type-name' instead of `type-id', - but they are essentially the same concept.) - - If ADDRESS_P is true, the postfix expression is the operand of the - `&' operator. CAST_P is true if this expression is the target of a - cast. - - Returns a representation of the expression. */ - -static tree -cp_parser_postfix_expression (cp_parser *parser, bool address_p, bool cast_p) -{ - cp_token *token; - enum rid keyword; - cp_id_kind idk = CP_ID_KIND_NONE; - tree postfix_expression = NULL_TREE; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Some of the productions are determined by keywords. */ - keyword = token->keyword; - switch (keyword) - { - case RID_DYNCAST: - case RID_STATCAST: - case RID_REINTCAST: - case RID_CONSTCAST: - { - tree type; - tree expression; - const char *saved_message; - - /* All of these can be handled in the same way from the point - of view of parsing. Begin by consuming the token - identifying the cast. */ - cp_lexer_consume_token (parser->lexer); - - /* New types cannot be defined in the cast. */ - saved_message = parser->type_definition_forbidden_message; - parser->type_definition_forbidden_message - = "types may not be defined in casts"; - - /* Look for the opening `<'. */ - cp_parser_require (parser, CPP_LESS, "`<'"); - /* Parse the type to which we are casting. */ - type = cp_parser_type_id (parser); - /* Look for the closing `>'. */ - cp_parser_require (parser, CPP_GREATER, "`>'"); - /* Restore the old message. */ - parser->type_definition_forbidden_message = saved_message; - - /* And the expression which is being cast. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - expression = cp_parser_expression (parser, /*cast_p=*/true); - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - /* Only type conversions to integral or enumeration types - can be used in constant-expressions. */ - if (!cast_valid_in_integral_constant_expression_p (type) - && (cp_parser_non_integral_constant_expression - (parser, - "a cast to a type other than an integral or " - "enumeration type"))) - return error_mark_node; - - switch (keyword) - { - case RID_DYNCAST: - postfix_expression - = build_dynamic_cast (type, expression); - break; - case RID_STATCAST: - postfix_expression - = build_static_cast (type, expression); - break; - case RID_REINTCAST: - postfix_expression - = build_reinterpret_cast (type, expression); - break; - case RID_CONSTCAST: - postfix_expression - = build_const_cast (type, expression); - break; - default: - gcc_unreachable (); - } - } - break; - - case RID_TYPEID: - { - tree type; - const char *saved_message; - bool saved_in_type_id_in_expr_p; - - /* Consume the `typeid' token. */ - cp_lexer_consume_token (parser->lexer); - /* Look for the `(' token. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - /* Types cannot be defined in a `typeid' expression. */ - saved_message = parser->type_definition_forbidden_message; - parser->type_definition_forbidden_message - = "types may not be defined in a `typeid\' expression"; - /* We can't be sure yet whether we're looking at a type-id or an - expression. */ - cp_parser_parse_tentatively (parser); - /* Try a type-id first. */ - saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p; - parser->in_type_id_in_expr_p = true; - type = cp_parser_type_id (parser); - parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p; - /* Look for the `)' token. Otherwise, we can't be sure that - we're not looking at an expression: consider `typeid (int - (3))', for example. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - /* If all went well, simply lookup the type-id. */ - if (cp_parser_parse_definitely (parser)) - postfix_expression = get_typeid (type); - /* Otherwise, fall back to the expression variant. */ - else - { - tree expression; - - /* Look for an expression. */ - expression = cp_parser_expression (parser, /*cast_p=*/false); - /* Compute its typeid. */ - postfix_expression = build_typeid (expression); - /* Look for the `)' token. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - } - /* Restore the saved message. */ - parser->type_definition_forbidden_message = saved_message; - /* `typeid' may not appear in an integral constant expression. */ - if (cp_parser_non_integral_constant_expression(parser, - "`typeid' operator")) - return error_mark_node; - } - break; - - case RID_TYPENAME: - { - tree type; - /* The syntax permitted here is the same permitted for an - elaborated-type-specifier. */ - type = cp_parser_elaborated_type_specifier (parser, - /*is_friend=*/false, - /*is_declaration=*/false); - postfix_expression = cp_parser_functional_cast (parser, type); - } - break; - - default: - { - tree type; - - /* If the next thing is a simple-type-specifier, we may be - looking at a functional cast. We could also be looking at - an id-expression. So, we try the functional cast, and if - that doesn't work we fall back to the primary-expression. */ - cp_parser_parse_tentatively (parser); - /* Look for the simple-type-specifier. */ - type = cp_parser_simple_type_specifier (parser, - /*decl_specs=*/NULL, - CP_PARSER_FLAGS_NONE); - /* Parse the cast itself. */ - if (!cp_parser_error_occurred (parser)) - postfix_expression - = cp_parser_functional_cast (parser, type); - /* If that worked, we're done. */ - if (cp_parser_parse_definitely (parser)) - break; - - /* If the functional-cast didn't work out, try a - compound-literal. */ - if (cp_parser_allow_gnu_extensions_p (parser) - && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - { - VEC(constructor_elt,gc) *initializer_list = NULL; - bool saved_in_type_id_in_expr_p; - - cp_parser_parse_tentatively (parser); - /* Consume the `('. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the type. */ - saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p; - parser->in_type_id_in_expr_p = true; - type = cp_parser_type_id (parser); - parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p; - /* Look for the `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - /* Look for the `{'. */ - cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"); - /* If things aren't going well, there's no need to - keep going. */ - if (!cp_parser_error_occurred (parser)) - { - bool non_constant_p; - /* Parse the initializer-list. */ - initializer_list - = cp_parser_initializer_list (parser, &non_constant_p); - /* Allow a trailing `,'. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) - cp_lexer_consume_token (parser->lexer); - /* Look for the final `}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - } - /* If that worked, we're definitely looking at a - compound-literal expression. */ - if (cp_parser_parse_definitely (parser)) - { - /* Warn the user that a compound literal is not - allowed in standard C++. */ - /* APPLE LOCAL Altivec initializers 3068233 */ - if (pedantic && TREE_CODE (type) != VECTOR_TYPE) - pedwarn ("ISO C++ forbids compound-literals"); - /* For simplicitly, we disallow compound literals in - constant-expressions for simpliicitly. We could - allow compound literals of integer type, whose - initializer was a constant, in constant - expressions. Permitting that usage, as a further - extension, would not change the meaning of any - currently accepted programs. (Of course, as - compound literals are not part of ISO C++, the - standard has nothing to say.) */ - if (cp_parser_non_integral_constant_expression - (parser, "non-constant compound literals")) - { - postfix_expression = error_mark_node; - break; - } - /* Form the representation of the compound-literal. */ - postfix_expression - = finish_compound_literal (type, initializer_list); - break; - } - } - - /* It must be a primary-expression. */ - postfix_expression - = cp_parser_primary_expression (parser, address_p, cast_p, - /*template_arg_p=*/false, - &idk); - } - break; - } - - /* Keep looping until the postfix-expression is complete. */ - while (true) - { - if (idk == CP_ID_KIND_UNQUALIFIED - && TREE_CODE (postfix_expression) == IDENTIFIER_NODE - && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)) - /* It is not a Koenig lookup function call. */ - postfix_expression - = unqualified_name_lookup_error (postfix_expression); - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_OPEN_SQUARE: - postfix_expression - = cp_parser_postfix_open_square_expression (parser, - postfix_expression, - false); - idk = CP_ID_KIND_NONE; - break; - - case CPP_OPEN_PAREN: - /* postfix-expression ( expression-list [opt] ) */ - { - bool koenig_p; - bool is_builtin_constant_p; - bool saved_integral_constant_expression_p = false; - bool saved_non_integral_constant_expression_p = false; - tree args; - - is_builtin_constant_p - = DECL_IS_BUILTIN_CONSTANT_P (postfix_expression); - if (is_builtin_constant_p) - { - /* The whole point of __builtin_constant_p is to allow - non-constant expressions to appear as arguments. */ - saved_integral_constant_expression_p - = parser->integral_constant_expression_p; - saved_non_integral_constant_expression_p - = parser->non_integral_constant_expression_p; - parser->integral_constant_expression_p = false; - } - args = (cp_parser_parenthesized_expression_list - (parser, /*is_attribute_list=*/false, - /*cast_p=*/false, - /*non_constant_p=*/NULL)); - if (is_builtin_constant_p) - { - parser->integral_constant_expression_p - = saved_integral_constant_expression_p; - parser->non_integral_constant_expression_p - = saved_non_integral_constant_expression_p; - } - - if (args == error_mark_node) - { - postfix_expression = error_mark_node; - break; - } - - /* Function calls are not permitted in - constant-expressions. */ - if (! builtin_valid_in_constant_expr_p (postfix_expression) - && cp_parser_non_integral_constant_expression (parser, - "a function call")) - { - postfix_expression = error_mark_node; - break; - } - - koenig_p = false; - if (idk == CP_ID_KIND_UNQUALIFIED) - { - if (TREE_CODE (postfix_expression) == IDENTIFIER_NODE) - { - if (args) - { - koenig_p = true; - postfix_expression - = perform_koenig_lookup (postfix_expression, args); - } - else - postfix_expression - = unqualified_fn_lookup_error (postfix_expression); - } - /* We do not perform argument-dependent lookup if - normal lookup finds a non-function, in accordance - with the expected resolution of DR 218. */ - else if (args && is_overloaded_fn (postfix_expression)) - { - tree fn = get_first_fn (postfix_expression); - - if (TREE_CODE (fn) == TEMPLATE_ID_EXPR) - fn = OVL_CURRENT (TREE_OPERAND (fn, 0)); - - /* Only do argument dependent lookup if regular - lookup does not find a set of member functions. - [basic.lookup.koenig]/2a */ - if (!DECL_FUNCTION_MEMBER_P (fn)) - { - koenig_p = true; - postfix_expression - = perform_koenig_lookup (postfix_expression, args); - } - } - } - - if (TREE_CODE (postfix_expression) == COMPONENT_REF) - { - tree instance = TREE_OPERAND (postfix_expression, 0); - tree fn = TREE_OPERAND (postfix_expression, 1); - - if (processing_template_decl - && (type_dependent_expression_p (instance) - || (!BASELINK_P (fn) - && TREE_CODE (fn) != FIELD_DECL) - || type_dependent_expression_p (fn) - || any_type_dependent_arguments_p (args))) - { - postfix_expression - = build_min_nt (CALL_EXPR, postfix_expression, - args, NULL_TREE); - break; - } - - if (BASELINK_P (fn)) - postfix_expression - = (build_new_method_call - (instance, fn, args, NULL_TREE, - (idk == CP_ID_KIND_QUALIFIED - ? LOOKUP_NONVIRTUAL : LOOKUP_NORMAL), - /*fn_p=*/NULL)); - else - postfix_expression - = finish_call_expr (postfix_expression, args, - /*disallow_virtual=*/false, - /*koenig_p=*/false); - } - else if (TREE_CODE (postfix_expression) == OFFSET_REF - || TREE_CODE (postfix_expression) == MEMBER_REF - || TREE_CODE (postfix_expression) == DOTSTAR_EXPR) - postfix_expression = (build_offset_ref_call_from_tree - (postfix_expression, args)); - else if (idk == CP_ID_KIND_QUALIFIED) - /* A call to a static class member, or a namespace-scope - function. */ - postfix_expression - = finish_call_expr (postfix_expression, args, - /*disallow_virtual=*/true, - koenig_p); - else - /* All other function calls. */ - postfix_expression - = finish_call_expr (postfix_expression, args, - /*disallow_virtual=*/false, - koenig_p); - - /* The POSTFIX_EXPRESSION is certainly no longer an id. */ - idk = CP_ID_KIND_NONE; - } - break; - - case CPP_DOT: - case CPP_DEREF: - /* postfix-expression . template [opt] id-expression - postfix-expression . pseudo-destructor-name - postfix-expression -> template [opt] id-expression - postfix-expression -> pseudo-destructor-name */ - - /* Consume the `.' or `->' operator. */ - cp_lexer_consume_token (parser->lexer); - - postfix_expression - = cp_parser_postfix_dot_deref_expression (parser, token->type, - postfix_expression, - false, &idk); - break; - - case CPP_PLUS_PLUS: - /* postfix-expression ++ */ - /* Consume the `++' token. */ - cp_lexer_consume_token (parser->lexer); - /* Generate a representation for the complete expression. */ - postfix_expression - = finish_increment_expr (postfix_expression, - POSTINCREMENT_EXPR); - /* Increments may not appear in constant-expressions. */ - if (cp_parser_non_integral_constant_expression (parser, - "an increment")) - postfix_expression = error_mark_node; - idk = CP_ID_KIND_NONE; - break; - - case CPP_MINUS_MINUS: - /* postfix-expression -- */ - /* Consume the `--' token. */ - cp_lexer_consume_token (parser->lexer); - /* Generate a representation for the complete expression. */ - postfix_expression - = finish_increment_expr (postfix_expression, - POSTDECREMENT_EXPR); - /* Decrements may not appear in constant-expressions. */ - if (cp_parser_non_integral_constant_expression (parser, - "a decrement")) - postfix_expression = error_mark_node; - idk = CP_ID_KIND_NONE; - break; - - default: - return postfix_expression; - } - } - - /* We should never get here. */ - gcc_unreachable (); - return error_mark_node; -} - -/* A subroutine of cp_parser_postfix_expression that also gets hijacked - by cp_parser_builtin_offsetof. We're looking for - - postfix-expression [ expression ] - - FOR_OFFSETOF is set if we're being called in that context, which - changes how we deal with integer constant expressions. */ - -static tree -cp_parser_postfix_open_square_expression (cp_parser *parser, - tree postfix_expression, - bool for_offsetof) -{ - tree index; - - /* Consume the `[' token. */ - cp_lexer_consume_token (parser->lexer); - - /* Parse the index expression. */ - /* ??? For offsetof, there is a question of what to allow here. If - offsetof is not being used in an integral constant expression context, - then we *could* get the right answer by computing the value at runtime. - If we are in an integral constant expression context, then we might - could accept any constant expression; hard to say without analysis. - Rather than open the barn door too wide right away, allow only integer - constant expressions here. */ - if (for_offsetof) - index = cp_parser_constant_expression (parser, false, NULL); - else - index = cp_parser_expression (parser, /*cast_p=*/false); - - /* Look for the closing `]'. */ - cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"); - - /* APPLE LOCAL begin CW asm blocks */ - if (inside_iasm_block) - if (TREE_CODE (postfix_expression) == BRACKET_EXPR - || TREE_CODE (index) == IDENTIFIER_NODE - || TREE_TYPE (index) == NULL_TREE) - return iasm_build_bracket (postfix_expression, index); - /* APPLE LOCAL end CW asm blocks */ - - /* Build the ARRAY_REF. */ - postfix_expression = grok_array_decl (postfix_expression, index); - - /* When not doing offsetof, array references are not permitted in - constant-expressions. */ - if (!for_offsetof - && (cp_parser_non_integral_constant_expression - (parser, "an array reference"))) - postfix_expression = error_mark_node; - - return postfix_expression; -} - -/* A subroutine of cp_parser_postfix_expression that also gets hijacked - by cp_parser_builtin_offsetof. We're looking for - - postfix-expression . template [opt] id-expression - postfix-expression . pseudo-destructor-name - postfix-expression -> template [opt] id-expression - postfix-expression -> pseudo-destructor-name - - FOR_OFFSETOF is set if we're being called in that context. That sorta - limits what of the above we'll actually accept, but nevermind. - TOKEN_TYPE is the "." or "->" token, which will already have been - removed from the stream. */ - -static tree -cp_parser_postfix_dot_deref_expression (cp_parser *parser, - enum cpp_ttype token_type, - tree postfix_expression, - bool for_offsetof, cp_id_kind *idk) -{ - tree name; - bool dependent_p; - bool pseudo_destructor_p; - tree scope = NULL_TREE; - - /* If this is a `->' operator, dereference the pointer. */ - if (token_type == CPP_DEREF) - postfix_expression = build_x_arrow (postfix_expression); - /* Check to see whether or not the expression is type-dependent. */ - dependent_p = type_dependent_expression_p (postfix_expression); - /* The identifier following the `->' or `.' is not qualified. */ - parser->scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - *idk = CP_ID_KIND_NONE; - /* Enter the scope corresponding to the type of the object - given by the POSTFIX_EXPRESSION. */ - if (!dependent_p && TREE_TYPE (postfix_expression) != NULL_TREE) - { - scope = TREE_TYPE (postfix_expression); - /* According to the standard, no expression should ever have - reference type. Unfortunately, we do not currently match - the standard in this respect in that our internal representation - of an expression may have reference type even when the standard - says it does not. Therefore, we have to manually obtain the - underlying type here. */ - scope = non_reference (scope); - /* The type of the POSTFIX_EXPRESSION must be complete. */ - if (scope == unknown_type_node) - { - error ("%qE does not have class type", postfix_expression); - scope = NULL_TREE; - } - else - scope = complete_type_or_else (scope, NULL_TREE); - /* Let the name lookup machinery know that we are processing a - class member access expression. */ - parser->context->object_type = scope; - /* If something went wrong, we want to be able to discern that case, - as opposed to the case where there was no SCOPE due to the type - of expression being dependent. */ - if (!scope) - scope = error_mark_node; - /* If the SCOPE was erroneous, make the various semantic analysis - functions exit quickly -- and without issuing additional error - messages. */ - if (scope == error_mark_node) - postfix_expression = error_mark_node; - } - - /* Assume this expression is not a pseudo-destructor access. */ - pseudo_destructor_p = false; - - /* If the SCOPE is a scalar type, then, if this is a valid program, - we must be looking at a pseudo-destructor-name. */ - if (scope && SCALAR_TYPE_P (scope)) - { - tree s; - tree type; - - cp_parser_parse_tentatively (parser); - /* Parse the pseudo-destructor-name. */ - s = NULL_TREE; - cp_parser_pseudo_destructor_name (parser, &s, &type); - if (cp_parser_parse_definitely (parser)) - { - pseudo_destructor_p = true; - postfix_expression - = finish_pseudo_destructor_expr (postfix_expression, - s, TREE_TYPE (type)); - } - } - - if (!pseudo_destructor_p) - { - /* If the SCOPE is not a scalar type, we are looking at an - ordinary class member access expression, rather than a - pseudo-destructor-name. */ - bool template_p; - /* Parse the id-expression. */ - name = (cp_parser_id_expression - (parser, - cp_parser_optional_template_keyword (parser), - /*check_dependency_p=*/true, - &template_p, - /*declarator_p=*/false, - /*optional_p=*/false)); - /* In general, build a SCOPE_REF if the member name is qualified. - However, if the name was not dependent and has already been - resolved; there is no need to build the SCOPE_REF. For example; - - struct X { void f(); }; - template <typename T> void f(T* t) { t->X::f(); } - - Even though "t" is dependent, "X::f" is not and has been resolved - to a BASELINK; there is no need to include scope information. */ - - /* But we do need to remember that there was an explicit scope for - virtual function calls. */ - if (parser->scope) - *idk = CP_ID_KIND_QUALIFIED; - - /* If the name is a template-id that names a type, we will get a - TYPE_DECL here. That is invalid code. */ - if (TREE_CODE (name) == TYPE_DECL) - { - error ("invalid use of %qD", name); - postfix_expression = error_mark_node; - } - else - { - if (name != error_mark_node && !BASELINK_P (name) && parser->scope) - { - name = build_qualified_name (/*type=*/NULL_TREE, - parser->scope, - name, - template_p); - parser->scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - } - if (scope && name && BASELINK_P (name)) - adjust_result_of_qualified_name_lookup - (name, BINFO_TYPE (BASELINK_ACCESS_BINFO (name)), scope); - postfix_expression - = finish_class_member_access_expr (postfix_expression, name, - template_p); - } - } - - /* We no longer need to look up names in the scope of the object on - the left-hand side of the `.' or `->' operator. */ - parser->context->object_type = NULL_TREE; - - /* Outside of offsetof, these operators may not appear in - constant-expressions. */ - if (!for_offsetof - && (cp_parser_non_integral_constant_expression - (parser, token_type == CPP_DEREF ? "'->'" : "`.'"))) - postfix_expression = error_mark_node; - - return postfix_expression; -} - -/* Parse a parenthesized expression-list. - - expression-list: - assignment-expression - expression-list, assignment-expression - - attribute-list: - expression-list - identifier - identifier, expression-list - - CAST_P is true if this expression is the target of a cast. - - Returns a TREE_LIST. The TREE_VALUE of each node is a - representation of an assignment-expression. Note that a TREE_LIST - is returned even if there is only a single expression in the list. - error_mark_node is returned if the ( and or ) are - missing. NULL_TREE is returned on no expressions. The parentheses - are eaten. IS_ATTRIBUTE_LIST is true if this is really an attribute - list being parsed. If NON_CONSTANT_P is non-NULL, *NON_CONSTANT_P - indicates whether or not all of the expressions in the list were - constant. */ - -static tree -cp_parser_parenthesized_expression_list (cp_parser* parser, - bool is_attribute_list, - bool cast_p, - bool *non_constant_p) -{ - tree expression_list = NULL_TREE; - bool fold_expr_p = is_attribute_list; - tree identifier = NULL_TREE; - - /* Assume all the expressions will be constant. */ - if (non_constant_p) - *non_constant_p = false; - - if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - return error_mark_node; - - /* Consume expressions until there are no more. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)) - while (true) - { - tree expr; - - /* At the beginning of attribute lists, check to see if the - next token is an identifier. */ - if (is_attribute_list - && cp_lexer_peek_token (parser->lexer)->type == CPP_NAME) - { - cp_token *token; - - /* Consume the identifier. */ - token = cp_lexer_consume_token (parser->lexer); - /* Save the identifier. */ - identifier = token->u.value; - } - else - { - /* Parse the next assignment-expression. */ - if (non_constant_p) - { - bool expr_non_constant_p; - expr = (cp_parser_constant_expression - (parser, /*allow_non_constant_p=*/true, - &expr_non_constant_p)); - if (expr_non_constant_p) - *non_constant_p = true; - } - else - expr = cp_parser_assignment_expression (parser, cast_p); - - if (fold_expr_p) - expr = fold_non_dependent_expr (expr); - - /* Add it to the list. We add error_mark_node - expressions to the list, so that we can still tell if - the correct form for a parenthesized expression-list - is found. That gives better errors. */ - expression_list = tree_cons (NULL_TREE, expr, expression_list); - - if (expr == error_mark_node) - goto skip_comma; - } - - /* After the first item, attribute lists look the same as - expression lists. */ - is_attribute_list = false; - - get_comma:; - /* If the next token isn't a `,', then we are done. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) - break; - - /* Otherwise, consume the `,' and keep going. */ - cp_lexer_consume_token (parser->lexer); - } - - if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - { - int ending; - - skip_comma:; - /* We try and resync to an unnested comma, as that will give the - user better diagnostics. */ - ending = cp_parser_skip_to_closing_parenthesis (parser, - /*recovering=*/true, - /*or_comma=*/true, - /*consume_paren=*/true); - if (ending < 0) - goto get_comma; - if (!ending) - return error_mark_node; - } - - /* We built up the list in reverse order so we must reverse it now. */ - expression_list = nreverse (expression_list); - if (identifier) - expression_list = tree_cons (NULL_TREE, identifier, expression_list); - - return expression_list; -} - -/* Parse a pseudo-destructor-name. - - pseudo-destructor-name: - :: [opt] nested-name-specifier [opt] type-name :: ~ type-name - :: [opt] nested-name-specifier template template-id :: ~ type-name - :: [opt] nested-name-specifier [opt] ~ type-name - - If either of the first two productions is used, sets *SCOPE to the - TYPE specified before the final `::'. Otherwise, *SCOPE is set to - NULL_TREE. *TYPE is set to the TYPE_DECL for the final type-name, - or ERROR_MARK_NODE if the parse fails. */ - -static void -cp_parser_pseudo_destructor_name (cp_parser* parser, - tree* scope, - tree* type) -{ - bool nested_name_specifier_p; - - /* Assume that things will not work out. */ - *type = error_mark_node; - - /* Look for the optional `::' operator. */ - cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/true); - /* 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=*/true, - /*type_p=*/false, - /*is_declaration=*/true) - != NULL_TREE); - /* Now, if we saw a nested-name-specifier, we might be doing the - second production. */ - if (nested_name_specifier_p - && cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE)) - { - /* Consume the `template' keyword. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the template-id. */ - cp_parser_template_id (parser, - /*template_keyword_p=*/true, - /*check_dependency_p=*/false, - /*is_declaration=*/true); - /* Look for the `::' token. */ - cp_parser_require (parser, CPP_SCOPE, "`::'"); - } - /* If the next token is not a `~', then there might be some - additional qualification. */ - else if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMPL)) - { - /* Look for the type-name. */ - *scope = TREE_TYPE (cp_parser_type_name (parser)); - - if (*scope == error_mark_node) - return; - - /* If we don't have ::~, then something has gone wrong. Since - the only caller of this function is looking for something - after `.' or `->' after a scalar type, most likely the - program is trying to get a member of a non-aggregate - type. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE) - || cp_lexer_peek_nth_token (parser->lexer, 2)->type != CPP_COMPL) - { - cp_parser_error (parser, "request for member of non-aggregate type"); - return; - } - - /* Look for the `::' token. */ - cp_parser_require (parser, CPP_SCOPE, "`::'"); - } - else - *scope = NULL_TREE; - - /* Look for the `~'. */ - cp_parser_require (parser, CPP_COMPL, "`~'"); - /* Look for the type-name again. We are not responsible for - checking that it matches the first type-name. */ - *type = cp_parser_type_name (parser); -} - -/* Parse a unary-expression. - - unary-expression: - postfix-expression - ++ cast-expression - -- cast-expression - unary-operator cast-expression - sizeof unary-expression - sizeof ( type-id ) - new-expression - delete-expression - - GNU Extensions: - - unary-expression: - __extension__ cast-expression - __alignof__ unary-expression - __alignof__ ( type-id ) - __real__ cast-expression - __imag__ cast-expression - && identifier - - ADDRESS_P is true iff the unary-expression is appearing as the - operand of the `&' operator. CAST_P is true if this expression is - the target of a cast. - - Returns a representation of the expression. */ - -static tree -cp_parser_unary_expression (cp_parser *parser, bool address_p, bool cast_p) -{ - cp_token *token; - enum tree_code unary_operator; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Some keywords give away the kind of expression. */ - if (token->type == CPP_KEYWORD) - { - enum rid keyword = token->keyword; - - switch (keyword) - { - /* APPLE LOCAL begin CW asm blocks */ - case RID_SIZEOF: - if (inside_iasm_block) - break; - - case RID_ALIGNOF: - /* APPLE LOCAL end CW asm blocks */ - { - tree operand; - enum tree_code op; - - op = keyword == RID_ALIGNOF ? ALIGNOF_EXPR : SIZEOF_EXPR; - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the operand. */ - operand = cp_parser_sizeof_operand (parser, keyword); - - if (TYPE_P (operand)) - return cxx_sizeof_or_alignof_type (operand, op, true); - else - return cxx_sizeof_or_alignof_expr (operand, op); - } - - case RID_NEW: - return cp_parser_new_expression (parser); - - case RID_DELETE: - return cp_parser_delete_expression (parser); - - case RID_EXTENSION: - { - /* The saved value of the PEDANTIC flag. */ - int saved_pedantic; - tree expr; - - /* Save away the PEDANTIC flag. */ - cp_parser_extension_opt (parser, &saved_pedantic); - /* Parse the cast-expression. */ - expr = cp_parser_simple_cast_expression (parser); - /* Restore the PEDANTIC flag. */ - pedantic = saved_pedantic; - - return expr; - } - - case RID_REALPART: - case RID_IMAGPART: - { - tree expression; - - /* Consume the `__real__' or `__imag__' token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the cast-expression. */ - expression = cp_parser_simple_cast_expression (parser); - /* Create the complete representation. */ - return build_x_unary_op ((keyword == RID_REALPART - ? REALPART_EXPR : IMAGPART_EXPR), - expression); - } - break; - - default: - break; - } - } - - /* Look for the `:: new' and `:: delete', which also signal the - beginning of a new-expression, or delete-expression, - respectively. If the next token is `::', then it might be one of - these. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)) - { - enum rid keyword; - - /* See if the token after the `::' is one of the keywords in - which we're interested. */ - keyword = cp_lexer_peek_nth_token (parser->lexer, 2)->keyword; - /* If it's `new', we have a new-expression. */ - if (keyword == RID_NEW) - return cp_parser_new_expression (parser); - /* Similarly, for `delete'. */ - else if (keyword == RID_DELETE) - return cp_parser_delete_expression (parser); - } - - /* Look for a unary operator. */ - unary_operator = cp_parser_unary_operator (token); - - /* APPLE LOCAL begin CW asm blocks */ - /* In the context of CW asm block, '*' followed by '+' or '-' is for - relative branch syntax. This is to allow "b *+8" which - is disallwed by darwin's assembler but nevertheless is needed to - be compatible with CW tools. */ - if (inside_iasm_block && unary_operator == INDIRECT_REF) - { - cp_token *token = cp_lexer_peek_nth_token (parser->lexer, 2); - if (token->type == CPP_PLUS || token->type == CPP_MINUS) - unary_operator = ERROR_MARK; - } - /* APPLE LOCAL end CW asm blocks */ - /* The `++' and `--' operators can be handled similarly, even though - they are not technically unary-operators in the grammar. */ - if (unary_operator == ERROR_MARK) - { - if (token->type == CPP_PLUS_PLUS) - unary_operator = PREINCREMENT_EXPR; - else if (token->type == CPP_MINUS_MINUS) - unary_operator = PREDECREMENT_EXPR; - /* Handle the GNU address-of-label extension. */ - else if (cp_parser_allow_gnu_extensions_p (parser) - && token->type == CPP_AND_AND) - { - tree identifier; - - /* Consume the '&&' token. */ - cp_lexer_consume_token (parser->lexer); - /* Look for the identifier. */ - identifier = cp_parser_identifier (parser); - /* Create an expression representing the address. */ - return finish_label_address_expr (identifier); - } - } - if (unary_operator != ERROR_MARK) - { - tree cast_expression; - tree expression = error_mark_node; - const char *non_constant_p = NULL; - - /* Consume the operator token. */ - token = cp_lexer_consume_token (parser->lexer); - /* Parse the cast-expression. */ - cast_expression - = cp_parser_cast_expression (parser, - unary_operator == ADDR_EXPR, - /*cast_p=*/false); - /* Now, build an appropriate representation. */ - switch (unary_operator) - { - case INDIRECT_REF: - non_constant_p = "`*'"; - expression = build_x_indirect_ref (cast_expression, "unary *"); - break; - - case ADDR_EXPR: - non_constant_p = "`&'"; - /* Fall through. */ - case BIT_NOT_EXPR: - /* APPLE LOCAL begin CW asm blocks */ - if (inside_iasm_block - && unary_operator == ADDR_EXPR - && TREE_CODE (cast_expression) == LABEL_DECL) - { - expression = finish_label_address_expr (DECL_NAME (cast_expression)); - break; - } - /* APPLE LOCAL end CW asm blocks */ - expression = build_x_unary_op (unary_operator, cast_expression); - break; - - case PREINCREMENT_EXPR: - case PREDECREMENT_EXPR: - non_constant_p = (unary_operator == PREINCREMENT_EXPR - ? "`++'" : "`--'"); - /* Fall through. */ - case UNARY_PLUS_EXPR: - case NEGATE_EXPR: - case TRUTH_NOT_EXPR: - /* APPLE LOCAL begin CW asm blocks */ - if (inside_iasm_block && TREE_TYPE (cast_expression) == 0) - { - expression = build1 (unary_operator, NULL_TREE, cast_expression); - break; - } - /* APPLE LOCAL end CW asm blocks */ - expression = finish_unary_op_expr (unary_operator, cast_expression); - break; - - default: - gcc_unreachable (); - } - - if (non_constant_p - && cp_parser_non_integral_constant_expression (parser, - non_constant_p)) - expression = error_mark_node; - - return expression; - } - - /* APPLE LOCAL begin CW asm blocks */ - /* Postfix expressions in CW asm are more restricted and handled - quite differently, so diverge from the usual expression - precedence sequence here. */ - if (inside_iasm_block) - return cp_parser_iasm_postfix_expression (parser, address_p, cast_p); - /* APPLE LOCAL end CW asm blocks */ - - return cp_parser_postfix_expression (parser, address_p, cast_p); -} - -/* Returns ERROR_MARK if TOKEN is not a unary-operator. If TOKEN is a - unary-operator, the corresponding tree code is returned. */ - -static enum tree_code -cp_parser_unary_operator (cp_token* token) -{ - switch (token->type) - { - case CPP_MULT: - return INDIRECT_REF; - - case CPP_AND: - return ADDR_EXPR; - - case CPP_PLUS: - return UNARY_PLUS_EXPR; - - case CPP_MINUS: - return NEGATE_EXPR; - - case CPP_NOT: - return TRUTH_NOT_EXPR; - - case CPP_COMPL: - return BIT_NOT_EXPR; - - /* APPLE LOCAL begin CW asm blocks */ - case CPP_NAME: - if (iasm_state >= iasm_decls - && flag_ms_asms - && strcasecmp (IDENTIFIER_POINTER (token->u.value), "offset") == 0) - return ADDR_EXPR; - /* APPLE LOCAL end CW asm blocks */ - - default: - return ERROR_MARK; - } -} - -/* Parse a new-expression. - - new-expression: - :: [opt] new new-placement [opt] new-type-id new-initializer [opt] - :: [opt] new new-placement [opt] ( type-id ) new-initializer [opt] - - Returns a representation of the expression. */ - -static tree -cp_parser_new_expression (cp_parser* parser) -{ - bool global_scope_p; - tree placement; - tree type; - tree initializer; - tree nelts; - - /* Look for the optional `::' operator. */ - global_scope_p - = (cp_parser_global_scope_opt (parser, - /*current_scope_valid_p=*/false) - != NULL_TREE); - /* Look for the `new' operator. */ - cp_parser_require_keyword (parser, RID_NEW, "`new'"); - /* There's no easy way to tell a new-placement from the - `( type-id )' construct. */ - cp_parser_parse_tentatively (parser); - /* Look for a new-placement. */ - placement = cp_parser_new_placement (parser); - /* If that didn't work out, there's no new-placement. */ - if (!cp_parser_parse_definitely (parser)) - placement = NULL_TREE; - - /* If the next token is a `(', then we have a parenthesized - type-id. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - { - /* Consume the `('. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the type-id. */ - type = cp_parser_type_id (parser); - /* Look for the closing `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - /* There should not be a direct-new-declarator in this production, - but GCC used to allowed this, so we check and emit a sensible error - message for this case. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE)) - { - error ("array bound forbidden after parenthesized type-id"); - inform ("try removing the parentheses around the type-id"); - cp_parser_direct_new_declarator (parser); - } - nelts = NULL_TREE; - } - /* Otherwise, there must be a new-type-id. */ - else - type = cp_parser_new_type_id (parser, &nelts); - - /* If the next token is a `(', then we have a new-initializer. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - initializer = cp_parser_new_initializer (parser); - else - initializer = NULL_TREE; - - /* A new-expression may not appear in an integral constant - expression. */ - if (cp_parser_non_integral_constant_expression (parser, "`new'")) - return error_mark_node; - - /* Create a representation of the new-expression. */ - return build_new (placement, type, nelts, initializer, global_scope_p); -} - -/* Parse a new-placement. - - new-placement: - ( expression-list ) - - Returns the same representation as for an expression-list. */ - -static tree -cp_parser_new_placement (cp_parser* parser) -{ - tree expression_list; - - /* Parse the expression-list. */ - expression_list = (cp_parser_parenthesized_expression_list - (parser, false, /*cast_p=*/false, - /*non_constant_p=*/NULL)); - - return expression_list; -} - -/* Parse a new-type-id. - - new-type-id: - type-specifier-seq new-declarator [opt] - - Returns the TYPE allocated. If the new-type-id indicates an array - type, *NELTS is set to the number of elements in the last array - bound; the TYPE will not include the last array bound. */ - -static tree -cp_parser_new_type_id (cp_parser* parser, tree *nelts) -{ - cp_decl_specifier_seq type_specifier_seq; - cp_declarator *new_declarator; - cp_declarator *declarator; - cp_declarator *outer_declarator; - const char *saved_message; - tree type; - - /* The type-specifier sequence must not contain type definitions. - (It cannot contain declarations of new types either, but if they - are not definitions we will catch that because they are not - complete.) */ - saved_message = parser->type_definition_forbidden_message; - parser->type_definition_forbidden_message - = "types may not be defined in a new-type-id"; - /* Parse the type-specifier-seq. */ - cp_parser_type_specifier_seq (parser, /*is_condition=*/false, - &type_specifier_seq); - /* Restore the old message. */ - parser->type_definition_forbidden_message = saved_message; - /* Parse the new-declarator. */ - new_declarator = cp_parser_new_declarator_opt (parser); - - /* Determine the number of elements in the last array dimension, if - any. */ - *nelts = NULL_TREE; - /* Skip down to the last array dimension. */ - declarator = new_declarator; - outer_declarator = NULL; - while (declarator && (declarator->kind == cdk_pointer - || declarator->kind == cdk_ptrmem)) - { - outer_declarator = declarator; - declarator = declarator->declarator; - } - while (declarator - && declarator->kind == cdk_array - && declarator->declarator - && declarator->declarator->kind == cdk_array) - { - outer_declarator = declarator; - declarator = declarator->declarator; - } - - if (declarator && declarator->kind == cdk_array) - { - *nelts = declarator->u.array.bounds; - if (*nelts == error_mark_node) - *nelts = integer_one_node; - - if (outer_declarator) - outer_declarator->declarator = declarator->declarator; - else - new_declarator = NULL; - } - - type = groktypename (&type_specifier_seq, new_declarator); - if (TREE_CODE (type) == ARRAY_TYPE && *nelts == NULL_TREE) - { - *nelts = array_type_nelts_top (type); - type = TREE_TYPE (type); - } - return type; -} - -/* Parse an (optional) new-declarator. - - new-declarator: - ptr-operator new-declarator [opt] - direct-new-declarator - - Returns the declarator. */ - -static cp_declarator * -cp_parser_new_declarator_opt (cp_parser* parser) -{ - enum tree_code code; - tree type; - cp_cv_quals cv_quals; - - /* We don't know if there's a ptr-operator next, or not. */ - cp_parser_parse_tentatively (parser); - /* Look for a ptr-operator. */ - code = cp_parser_ptr_operator (parser, &type, &cv_quals); - /* If that worked, look for more new-declarators. */ - if (cp_parser_parse_definitely (parser)) - { - cp_declarator *declarator; - - /* Parse another optional declarator. */ - declarator = cp_parser_new_declarator_opt (parser); - - /* Create the representation of the declarator. */ - if (type) - declarator = make_ptrmem_declarator (cv_quals, type, declarator); - else if (code == INDIRECT_REF) - declarator = make_pointer_declarator (cv_quals, declarator); - else - declarator = make_reference_declarator (cv_quals, declarator); - - return declarator; - } - - /* If the next token is a `[', there is a direct-new-declarator. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE)) - return cp_parser_direct_new_declarator (parser); - - return NULL; -} - -/* Parse a direct-new-declarator. - - direct-new-declarator: - [ expression ] - direct-new-declarator [constant-expression] - - */ - -static cp_declarator * -cp_parser_direct_new_declarator (cp_parser* parser) -{ - cp_declarator *declarator = NULL; - - while (true) - { - tree expression; - - /* Look for the opening `['. */ - cp_parser_require (parser, CPP_OPEN_SQUARE, "`['"); - /* The first expression is not required to be constant. */ - if (!declarator) - { - expression = cp_parser_expression (parser, /*cast_p=*/false); - /* The standard requires that the expression have integral - type. DR 74 adds enumeration types. We believe that the - real intent is that these expressions be handled like the - expression in a `switch' condition, which also allows - classes with a single conversion to integral or - enumeration type. */ - if (!processing_template_decl) - { - expression - = build_expr_type_conversion (WANT_INT | WANT_ENUM, - expression, - /*complain=*/true); - if (!expression) - { - error ("expression in new-declarator must have integral " - "or enumeration type"); - expression = error_mark_node; - } - } - } - /* But all the other expressions must be. */ - else - expression - = cp_parser_constant_expression (parser, - /*allow_non_constant=*/false, - NULL); - /* Look for the closing `]'. */ - cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"); - - /* Add this bound to the declarator. */ - declarator = make_array_declarator (declarator, expression); - - /* If the next token is not a `[', then there are no more - bounds. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_SQUARE)) - break; - } - - return declarator; -} - -/* Parse a new-initializer. - - new-initializer: - ( expression-list [opt] ) - - Returns a representation of the expression-list. If there is no - expression-list, VOID_ZERO_NODE is returned. */ - -static tree -cp_parser_new_initializer (cp_parser* parser) -{ - tree expression_list; - - expression_list = (cp_parser_parenthesized_expression_list - (parser, false, /*cast_p=*/false, - /*non_constant_p=*/NULL)); - if (!expression_list) - expression_list = void_zero_node; - - return expression_list; -} - -/* Parse a delete-expression. - - delete-expression: - :: [opt] delete cast-expression - :: [opt] delete [ ] cast-expression - - Returns a representation of the expression. */ - -static tree -cp_parser_delete_expression (cp_parser* parser) -{ - bool global_scope_p; - bool array_p; - tree expression; - - /* Look for the optional `::' operator. */ - global_scope_p - = (cp_parser_global_scope_opt (parser, - /*current_scope_valid_p=*/false) - != NULL_TREE); - /* Look for the `delete' keyword. */ - cp_parser_require_keyword (parser, RID_DELETE, "`delete'"); - /* See if the array syntax is in use. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE)) - { - /* Consume the `[' token. */ - cp_lexer_consume_token (parser->lexer); - /* Look for the `]' token. */ - cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"); - /* Remember that this is the `[]' construct. */ - array_p = true; - } - else - array_p = false; - - /* Parse the cast-expression. */ - expression = cp_parser_simple_cast_expression (parser); - - /* A delete-expression may not appear in an integral constant - expression. */ - if (cp_parser_non_integral_constant_expression (parser, "`delete'")) - return error_mark_node; - - return delete_sanity (expression, NULL_TREE, array_p, global_scope_p); -} - -/* Parse a cast-expression. - - cast-expression: - unary-expression - ( type-id ) cast-expression - - ADDRESS_P is true iff the unary-expression is appearing as the - operand of the `&' operator. CAST_P is true if this expression is - the target of a cast. - - Returns a representation of the expression. */ - -static tree -cp_parser_cast_expression (cp_parser *parser, bool address_p, bool cast_p) -{ - /* If it's a `(', then we might be looking at a cast. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - { - tree type = NULL_TREE; - tree expr = NULL_TREE; - bool compound_literal_p; - const char *saved_message; - - /* There's no way to know yet whether or not this is a cast. - For example, `(int (3))' is a unary-expression, while `(int) - 3' is a cast. So, we resort to parsing tentatively. */ - cp_parser_parse_tentatively (parser); - /* Types may not be defined in a cast. */ - saved_message = parser->type_definition_forbidden_message; - parser->type_definition_forbidden_message - = "types may not be defined in casts"; - /* Consume the `('. */ - cp_lexer_consume_token (parser->lexer); - /* A very tricky bit is that `(struct S) { 3 }' is a - compound-literal (which we permit in C++ as an extension). - But, that construct is not a cast-expression -- it is a - postfix-expression. (The reason is that `(struct S) { 3 }.i' - is legal; if the compound-literal were a cast-expression, - you'd need an extra set of parentheses.) But, if we parse - the type-id, and it happens to be a class-specifier, then we - will commit to the parse at that point, because we cannot - undo the action that is done when creating a new class. So, - then we cannot back up and do a postfix-expression. - - Therefore, we scan ahead to the closing `)', and check to see - if the token after the `)' is a `{'. If so, we are not - looking at a cast-expression. - - Save tokens so that we can put them back. */ - cp_lexer_save_tokens (parser->lexer); - /* Skip tokens until the next token is a closing parenthesis. - If we find the closing `)', and the next token is a `{', then - we are looking at a compound-literal. */ - compound_literal_p - = (cp_parser_skip_to_closing_parenthesis (parser, false, false, - /*consume_paren=*/true) - && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)); - /* Roll back the tokens we skipped. */ - cp_lexer_rollback_tokens (parser->lexer); - /* If we were looking at a compound-literal, simulate an error - so that the call to cp_parser_parse_definitely below will - fail. */ - if (compound_literal_p) - cp_parser_simulate_error (parser); - else - { - bool saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p; - parser->in_type_id_in_expr_p = true; - /* Look for the type-id. */ - type = cp_parser_type_id (parser); - /* Look for the closing `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p; - } - - /* Restore the saved message. */ - parser->type_definition_forbidden_message = saved_message; - - /* If ok so far, parse the dependent expression. We cannot be - sure it is a cast. Consider `(T ())'. It is a parenthesized - ctor of T, but looks like a cast to function returning T - without a dependent expression. */ - if (!cp_parser_error_occurred (parser)) - expr = cp_parser_cast_expression (parser, - /*address_p=*/false, - /*cast_p=*/true); - - if (cp_parser_parse_definitely (parser)) - { - /* Warn about old-style casts, if so requested. */ - if (warn_old_style_cast - && !in_system_header - && !VOID_TYPE_P (type) - && current_lang_name != lang_name_c) - warning (OPT_Wold_style_cast, "use of old-style cast"); - - /* Only type conversions to integral or enumeration types - can be used in constant-expressions. */ - if (!cast_valid_in_integral_constant_expression_p (type) - && (cp_parser_non_integral_constant_expression - (parser, - "a cast to a type other than an integral or " - "enumeration type"))) - return error_mark_node; - - /* Perform the cast. */ - expr = build_c_cast (type, expr); - /* APPLE LOCAL begin radar 4426814 */ - return (c_dialect_objc() && flag_objc_gc) - /* APPLE LOCAL radar 5276085 */ - ? objc_build_weak_reference_tree (expr) : expr; - /* APPLE LOCAL end radar 4426814 */ - } - } - - /* If we get here, then it's not a cast, so it must be a - unary-expression. */ - /* APPLE LOCAL begin radar 4426814 */ - if (c_dialect_objc() && flag_objc_gc) - /* APPLE LOCAL radar 5276085 */ - return objc_build_weak_reference_tree ( - cp_parser_unary_expression (parser, address_p, cast_p)); - else - return cp_parser_unary_expression (parser, address_p, cast_p); - /* APPLE LOCAL end radar 4426814 */ -} - -/* Parse a binary expression of the general form: - - pm-expression: - cast-expression - pm-expression .* cast-expression - pm-expression ->* cast-expression - - multiplicative-expression: - pm-expression - multiplicative-expression * pm-expression - multiplicative-expression / pm-expression - multiplicative-expression % pm-expression - - additive-expression: - multiplicative-expression - additive-expression + multiplicative-expression - additive-expression - multiplicative-expression - - shift-expression: - additive-expression - shift-expression << additive-expression - shift-expression >> additive-expression - - relational-expression: - shift-expression - relational-expression < shift-expression - relational-expression > shift-expression - relational-expression <= shift-expression - relational-expression >= shift-expression - - GNU Extension: - - relational-expression: - relational-expression <? shift-expression - relational-expression >? shift-expression - - equality-expression: - relational-expression - equality-expression == relational-expression - equality-expression != relational-expression - - and-expression: - equality-expression - and-expression & equality-expression - - exclusive-or-expression: - and-expression - exclusive-or-expression ^ and-expression - - inclusive-or-expression: - exclusive-or-expression - inclusive-or-expression | exclusive-or-expression - - logical-and-expression: - inclusive-or-expression - logical-and-expression && inclusive-or-expression - - logical-or-expression: - logical-and-expression - logical-or-expression || logical-and-expression - - All these are implemented with a single function like: - - binary-expression: - simple-cast-expression - binary-expression <token> binary-expression - - CAST_P is true if this expression is the target of a cast. - - The binops_by_token map is used to get the tree codes for each <token> type. - binary-expressions are associated according to a precedence table. */ - -#define TOKEN_PRECEDENCE(token) \ - ((token->type == CPP_GREATER && !parser->greater_than_is_operator_p) \ - ? PREC_NOT_OPERATOR \ - : binops_by_token[token->type].prec) - -static tree -cp_parser_binary_expression (cp_parser* parser, bool cast_p) -{ - cp_parser_expression_stack stack; - cp_parser_expression_stack_entry *sp = &stack[0]; - tree lhs, rhs; - cp_token *token; - enum tree_code tree_type; - enum cp_parser_prec prec = PREC_NOT_OPERATOR, new_prec, lookahead_prec; - bool overloaded_p; - - /* Parse the first expression. */ - lhs = cp_parser_cast_expression (parser, /*address_p=*/false, cast_p); - - for (;;) - { - /* Get an operator token. */ - token = cp_lexer_peek_token (parser->lexer); - - new_prec = TOKEN_PRECEDENCE (token); - - /* APPLE LOCAL begin CW asm blocks */ - if (flag_iasm_blocks && inside_iasm_block) - { - if ((token->flags & BOL) != 0) - new_prec = PREC_NOT_OPERATOR; - } - /* APPLE LOCAL end CW asm blocks */ - - /* Popping an entry off the stack means we completed a subexpression: - - either we found a token which is not an operator (`>' where it is not - an operator, or prec == PREC_NOT_OPERATOR), in which case popping - will happen repeatedly; - - or, we found an operator which has lower priority. This is the case - where the recursive descent *ascends*, as in `3 * 4 + 5' after - parsing `3 * 4'. */ - if (new_prec <= prec) - { - if (sp == stack) - break; - else - goto pop; - } - - get_rhs: - tree_type = binops_by_token[token->type].tree_type; - - /* We used the operator token. */ - cp_lexer_consume_token (parser->lexer); - - /* Extract another operand. It may be the RHS of this expression - or the LHS of a new, higher priority expression. */ - rhs = cp_parser_simple_cast_expression (parser); - - /* Get another operator token. Look up its precedence to avoid - building a useless (immediately popped) stack entry for common - cases such as 3 + 4 + 5 or 3 * 4 + 5. */ - token = cp_lexer_peek_token (parser->lexer); - lookahead_prec = TOKEN_PRECEDENCE (token); - - /* APPLE LOCAL begin CW asm blocks */ - if (flag_iasm_blocks && inside_iasm_block) - { - if ((token->flags & BOL) != 0) - lookahead_prec = PREC_NOT_OPERATOR; - } - /* APPLE LOCAL end CW asm blocks */ - - if (lookahead_prec > new_prec) - { - /* ... and prepare to parse the RHS of the new, higher priority - expression. Since precedence levels on the stack are - monotonically increasing, we do not have to care about - stack overflows. */ - sp->prec = prec; - sp->tree_type = tree_type; - sp->lhs = lhs; - sp++; - lhs = rhs; - prec = new_prec; - new_prec = lookahead_prec; - goto get_rhs; - - pop: - /* If the stack is not empty, we have parsed into LHS the right side - (`4' in the example above) of an expression we had suspended. - We can use the information on the stack to recover the LHS (`3') - from the stack together with the tree code (`MULT_EXPR'), and - the precedence of the higher level subexpression - (`PREC_ADDITIVE_EXPRESSION'). TOKEN is the CPP_PLUS token, - which will be used to actually build the additive expression. */ - --sp; - prec = sp->prec; - tree_type = sp->tree_type; - rhs = lhs; - lhs = sp->lhs; - } - - /* APPLE LOCAL begin CW asm blocks */ - if (inside_iasm_block && TREE_CODE (rhs) == COMPOUND_EXPR) - { - gcc_assert (TREE_CODE (TREE_OPERAND (rhs, 1)) == IDENTIFIER_NODE); - lhs = build_x_binary_op (tree_type, lhs, TREE_OPERAND (rhs, 0), &overloaded_p); - lhs = iasm_build_register_offset (lhs, TREE_OPERAND (rhs, 1)); - return lhs; - } - if (inside_iasm_block) - { - if (TREE_CODE (rhs) == IDENTIFIER_NODE - || TREE_CODE (lhs) == IDENTIFIER_NODE - || TREE_TYPE (rhs) == NULL_TREE - || TREE_TYPE (lhs) == NULL_TREE) - { - lhs = build2 (tree_type, NULL_TREE, lhs, rhs); - continue; - } - } - - /* APPLE LOCAL end CW asm blocks */ - overloaded_p = false; - lhs = build_x_binary_op (tree_type, lhs, rhs, &overloaded_p); - - /* If the binary operator required the use of an overloaded operator, - then this expression cannot be an integral constant-expression. - An overloaded operator can be used even if both operands are - otherwise permissible in an integral constant-expression if at - least one of the operands is of enumeration type. */ - - if (overloaded_p - && (cp_parser_non_integral_constant_expression - (parser, "calls to overloaded operators"))) - return error_mark_node; - } - - return lhs; -} - - -/* Parse the `? expression : assignment-expression' part of a - conditional-expression. The LOGICAL_OR_EXPR is the - logical-or-expression that started the conditional-expression. - Returns a representation of the entire conditional-expression. - - This routine is used by cp_parser_assignment_expression. - - ? expression : assignment-expression - - GNU Extensions: - - ? : assignment-expression */ - -static tree -cp_parser_question_colon_clause (cp_parser* parser, tree logical_or_expr) -{ - tree expr; - tree assignment_expr; - - /* Consume the `?' token. */ - cp_lexer_consume_token (parser->lexer); - if (cp_parser_allow_gnu_extensions_p (parser) - && cp_lexer_next_token_is (parser->lexer, CPP_COLON)) - /* Implicit true clause. */ - expr = NULL_TREE; - else - /* Parse the expression. */ - expr = cp_parser_expression (parser, /*cast_p=*/false); - - /* The next token should be a `:'. */ - cp_parser_require (parser, CPP_COLON, "`:'"); - /* Parse the assignment-expression. */ - assignment_expr = cp_parser_assignment_expression (parser, /*cast_p=*/false); - - /* Build the conditional-expression. */ - return build_x_conditional_expr (logical_or_expr, - expr, - assignment_expr); -} - -/* Parse an assignment-expression. - - assignment-expression: - conditional-expression - logical-or-expression assignment-operator assignment_expression - throw-expression - - CAST_P is true if this expression is the target of a cast. - - Returns a representation for the expression. */ - -static tree -cp_parser_assignment_expression (cp_parser* parser, bool cast_p) -{ - tree expr; - - /* If the next token is the `throw' keyword, then we're looking at - a throw-expression. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_THROW)) - expr = cp_parser_throw_expression (parser); - /* Otherwise, it must be that we are looking at a - logical-or-expression. */ - else - { - /* Parse the binary expressions (logical-or-expression). */ - expr = cp_parser_binary_expression (parser, cast_p); - /* If the next token is a `?' then we're actually looking at a - conditional-expression. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_QUERY)) - return cp_parser_question_colon_clause (parser, expr); - else - { - enum tree_code assignment_operator; - - /* If it's an assignment-operator, we're using the second - production. */ - assignment_operator - = cp_parser_assignment_operator_opt (parser); - if (assignment_operator != ERROR_MARK) - { - tree rhs; - - /* Parse the right-hand side of the assignment. */ - rhs = cp_parser_assignment_expression (parser, cast_p); - /* An assignment may not appear in a - constant-expression. */ - if (cp_parser_non_integral_constant_expression (parser, - "an assignment")) - return error_mark_node; - /* Build the assignment expression. */ - expr = build_x_modify_expr (expr, - assignment_operator, - rhs); - } - } - } - - return expr; -} - -/* Parse an (optional) assignment-operator. - - assignment-operator: one of - = *= /= %= += -= >>= <<= &= ^= |= - - GNU Extension: - - assignment-operator: one of - <?= >?= - - If the next token is an assignment operator, the corresponding tree - code is returned, and the token is consumed. For example, for - `+=', PLUS_EXPR is returned. For `=' itself, the code returned is - NOP_EXPR. For `/', TRUNC_DIV_EXPR is returned; for `%', - TRUNC_MOD_EXPR is returned. If TOKEN is not an assignment - operator, ERROR_MARK is returned. */ - -static enum tree_code -cp_parser_assignment_operator_opt (cp_parser* parser) -{ - enum tree_code op; - cp_token *token; - - /* Peek at the next toen. */ - token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_EQ: - op = NOP_EXPR; - break; - - case CPP_MULT_EQ: - op = MULT_EXPR; - break; - - case CPP_DIV_EQ: - op = TRUNC_DIV_EXPR; - break; - - case CPP_MOD_EQ: - op = TRUNC_MOD_EXPR; - break; - - case CPP_PLUS_EQ: - op = PLUS_EXPR; - break; - - case CPP_MINUS_EQ: - op = MINUS_EXPR; - break; - - case CPP_RSHIFT_EQ: - op = RSHIFT_EXPR; - break; - - case CPP_LSHIFT_EQ: - op = LSHIFT_EXPR; - break; - - case CPP_AND_EQ: - op = BIT_AND_EXPR; - break; - - case CPP_XOR_EQ: - op = BIT_XOR_EXPR; - break; - - case CPP_OR_EQ: - op = BIT_IOR_EXPR; - break; - - default: - /* Nothing else is an assignment operator. */ - op = ERROR_MARK; - } - - /* If it was an assignment operator, consume it. */ - if (op != ERROR_MARK) - cp_lexer_consume_token (parser->lexer); - - return op; -} - -/* Parse an expression. - - expression: - assignment-expression - expression , assignment-expression - - CAST_P is true if this expression is the target of a cast. - - Returns a representation of the expression. */ - -static tree -cp_parser_expression (cp_parser* parser, bool cast_p) -{ - tree expression = NULL_TREE; - - while (true) - { - tree assignment_expression; - - /* Parse the next assignment-expression. */ - assignment_expression - = cp_parser_assignment_expression (parser, cast_p); - /* If this is the first assignment-expression, we can just - save it away. */ - if (!expression) - expression = assignment_expression; - else - expression = build_x_compound_expr (expression, - assignment_expression); - /* If the next token is not a comma, then we are done with the - expression. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) - break; - /* Consume the `,'. */ - cp_lexer_consume_token (parser->lexer); - /* A comma operator cannot appear in a constant-expression. */ - if (cp_parser_non_integral_constant_expression (parser, - "a comma operator")) - expression = error_mark_node; - } - - return expression; -} - -/* Parse a constant-expression. - - constant-expression: - conditional-expression - - If ALLOW_NON_CONSTANT_P a non-constant expression is silently - accepted. If ALLOW_NON_CONSTANT_P is true and the expression is not - constant, *NON_CONSTANT_P is set to TRUE. If ALLOW_NON_CONSTANT_P - is false, NON_CONSTANT_P should be NULL. */ - -static tree -cp_parser_constant_expression (cp_parser* parser, - bool allow_non_constant_p, - bool *non_constant_p) -{ - bool saved_integral_constant_expression_p; - bool saved_allow_non_integral_constant_expression_p; - bool saved_non_integral_constant_expression_p; - tree expression; - - /* It might seem that we could simply parse the - conditional-expression, and then check to see if it were - TREE_CONSTANT. However, an expression that is TREE_CONSTANT is - one that the compiler can figure out is constant, possibly after - doing some simplifications or optimizations. The standard has a - precise definition of constant-expression, and we must honor - that, even though it is somewhat more restrictive. - - For example: - - int i[(2, 3)]; - - is not a legal declaration, because `(2, 3)' is not a - constant-expression. The `,' operator is forbidden in a - constant-expression. However, GCC's constant-folding machinery - will fold this operation to an INTEGER_CST for `3'. */ - - /* Save the old settings. */ - saved_integral_constant_expression_p = parser->integral_constant_expression_p; - saved_allow_non_integral_constant_expression_p - = parser->allow_non_integral_constant_expression_p; - saved_non_integral_constant_expression_p = parser->non_integral_constant_expression_p; - /* We are now parsing a constant-expression. */ - parser->integral_constant_expression_p = true; - parser->allow_non_integral_constant_expression_p = allow_non_constant_p; - parser->non_integral_constant_expression_p = false; - /* Although the grammar says "conditional-expression", we parse an - "assignment-expression", which also permits "throw-expression" - and the use of assignment operators. In the case that - ALLOW_NON_CONSTANT_P is false, we get better errors than we would - otherwise. In the case that ALLOW_NON_CONSTANT_P is true, it is - actually essential that we look for an assignment-expression. - For example, cp_parser_initializer_clauses uses this function to - determine whether a particular assignment-expression is in fact - constant. */ - expression = cp_parser_assignment_expression (parser, /*cast_p=*/false); - /* Restore the old settings. */ - parser->integral_constant_expression_p - = saved_integral_constant_expression_p; - parser->allow_non_integral_constant_expression_p - = saved_allow_non_integral_constant_expression_p; - if (allow_non_constant_p) - *non_constant_p = parser->non_integral_constant_expression_p; - else if (parser->non_integral_constant_expression_p) - expression = error_mark_node; - parser->non_integral_constant_expression_p - = saved_non_integral_constant_expression_p; - - return expression; -} - -/* Parse __builtin_offsetof. - - offsetof-expression: - "__builtin_offsetof" "(" type-id "," offsetof-member-designator ")" - - offsetof-member-designator: - id-expression - | offsetof-member-designator "." id-expression - | offsetof-member-designator "[" expression "]" */ - -static tree -cp_parser_builtin_offsetof (cp_parser *parser) -{ - int save_ice_p, save_non_ice_p; - tree type, expr; - cp_id_kind dummy; - - /* We're about to accept non-integral-constant things, but will - definitely yield an integral constant expression. Save and - restore these values around our local parsing. */ - save_ice_p = parser->integral_constant_expression_p; - save_non_ice_p = parser->non_integral_constant_expression_p; - - /* Consume the "__builtin_offsetof" token. */ - cp_lexer_consume_token (parser->lexer); - /* Consume the opening `('. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - /* Parse the type-id. */ - type = cp_parser_type_id (parser); - /* Look for the `,'. */ - cp_parser_require (parser, CPP_COMMA, "`,'"); - - /* Build the (type *)null that begins the traditional offsetof macro. */ - expr = build_static_cast (build_pointer_type (type), null_pointer_node); - - /* Parse the offsetof-member-designator. We begin as if we saw "expr->". */ - expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DEREF, expr, - true, &dummy); - while (true) - { - cp_token *token = cp_lexer_peek_token (parser->lexer); - switch (token->type) - { - case CPP_OPEN_SQUARE: - /* offsetof-member-designator "[" expression "]" */ - expr = cp_parser_postfix_open_square_expression (parser, expr, true); - break; - - case CPP_DOT: - /* offsetof-member-designator "." identifier */ - cp_lexer_consume_token (parser->lexer); - expr = cp_parser_postfix_dot_deref_expression (parser, CPP_DOT, expr, - true, &dummy); - break; - - case CPP_CLOSE_PAREN: - /* Consume the ")" token. */ - cp_lexer_consume_token (parser->lexer); - goto success; - - default: - /* Error. We know the following require will fail, but - that gives the proper error message. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - cp_parser_skip_to_closing_parenthesis (parser, true, false, true); - expr = error_mark_node; - goto failure; - } - } - - success: - /* If we're processing a template, we can't finish the semantics yet. - Otherwise we can fold the entire expression now. */ - if (processing_template_decl) - expr = build1 (OFFSETOF_EXPR, size_type_node, expr); - else - expr = finish_offsetof (expr); - - failure: - parser->integral_constant_expression_p = save_ice_p; - parser->non_integral_constant_expression_p = save_non_ice_p; - - return expr; -} - -/* Statements [gram.stmt.stmt] */ - -/* Parse a statement. - - statement: - labeled-statement - expression-statement - compound-statement - selection-statement - iteration-statement - jump-statement - declaration-statement - try-block - - IN_COMPOUND is true when the statement is nested inside a - cp_parser_compound_statement; this matters for certain pragmas. */ - -static void -cp_parser_statement (cp_parser* parser, tree in_statement_expr, - bool in_compound) -{ - tree statement; - cp_token *token; - location_t statement_location; - - restart: - /* There is no statement yet. */ - statement = NULL_TREE; - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Remember the location of the first token in the statement. */ - statement_location = token->location; - /* If this is a keyword, then that will often determine what kind of - statement we have. */ - if (token->type == CPP_KEYWORD) - { - enum rid keyword = token->keyword; - - switch (keyword) - { - case RID_CASE: - case RID_DEFAULT: - /* Looks like a labeled-statement with a case label. - Parse the label, and then use tail recursion to parse - the statement. */ - cp_parser_label_for_labeled_statement (parser); - goto restart; - - case RID_IF: - case RID_SWITCH: - statement = cp_parser_selection_statement (parser); - break; - - case RID_WHILE: - case RID_DO: - case RID_FOR: - statement = cp_parser_iteration_statement (parser); - break; - - case RID_BREAK: - case RID_CONTINUE: - case RID_RETURN: - case RID_GOTO: - statement = cp_parser_jump_statement (parser); - break; - - /* Objective-C++ exception-handling constructs. */ - case RID_AT_TRY: - case RID_AT_CATCH: - case RID_AT_FINALLY: - case RID_AT_SYNCHRONIZED: - case RID_AT_THROW: - statement = cp_parser_objc_statement (parser); - break; - - case RID_TRY: - statement = cp_parser_try_block (parser); - break; - - default: - /* It might be a keyword like `int' that can start a - declaration-statement. */ - break; - } - } - else if (token->type == CPP_NAME) - { - /* If the next token is a `:', then we are looking at a - labeled-statement. */ - token = cp_lexer_peek_nth_token (parser->lexer, 2); - if (token->type == CPP_COLON) - { - /* Looks like a labeled-statement with an ordinary label. - Parse the label, and then use tail recursion to parse - the statement. */ - cp_parser_label_for_labeled_statement (parser); - goto restart; - } - } - /* Anything that starts with a `{' must be a compound-statement. */ - else if (token->type == CPP_OPEN_BRACE) - /* APPLE LOCAL radar 5982990 */ - statement = cp_parser_compound_statement (parser, NULL, false, false); - /* CPP_PRAGMA is a #pragma inside a function body, which constitutes - a statement all its own. */ - else if (token->type == CPP_PRAGMA) - { - /* Only certain OpenMP pragmas are attached to statements, and thus - are considered statements themselves. All others are not. In - the context of a compound, accept the pragma as a "statement" and - return so that we can check for a close brace. Otherwise we - require a real statement and must go back and read one. */ - if (in_compound) - cp_parser_pragma (parser, pragma_compound); - else if (!cp_parser_pragma (parser, pragma_stmt)) - goto restart; - return; - } - else if (token->type == CPP_EOF) - { - cp_parser_error (parser, "expected statement"); - return; - } - - /* Everything else must be a declaration-statement or an - expression-statement. Try for the declaration-statement - first, unless we are looking at a `;', in which case we know that - we have an expression-statement. */ - if (!statement) - { - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - { - cp_parser_parse_tentatively (parser); - /* Try to parse the declaration-statement. */ - cp_parser_declaration_statement (parser); - /* If that worked, we're done. */ - if (cp_parser_parse_definitely (parser)) - return; - } - /* Look for an expression-statement instead. */ - statement = cp_parser_expression_statement (parser, in_statement_expr); - } - - /* Set the line number for the statement. */ - if (statement && STATEMENT_CODE_P (TREE_CODE (statement))) - SET_EXPR_LOCATION (statement, statement_location); -} - -/* Parse the label for a labeled-statement, i.e. - - identifier : - case constant-expression : - default : - - GNU Extension: - case constant-expression ... constant-expression : statement - - When a label is parsed without errors, the label is added to the - parse tree by the finish_* functions, so this function doesn't - have to return the label. */ - -static void -cp_parser_label_for_labeled_statement (cp_parser* parser) -{ - cp_token *token; - - /* The next token should be an identifier. */ - token = cp_lexer_peek_token (parser->lexer); - if (token->type != CPP_NAME - && token->type != CPP_KEYWORD) - { - cp_parser_error (parser, "expected labeled-statement"); - return; - } - - switch (token->keyword) - { - case RID_CASE: - { - tree expr, expr_hi; - cp_token *ellipsis; - - /* Consume the `case' token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the constant-expression. */ - expr = cp_parser_constant_expression (parser, - /*allow_non_constant_p=*/false, - NULL); - - ellipsis = cp_lexer_peek_token (parser->lexer); - if (ellipsis->type == CPP_ELLIPSIS) - { - /* Consume the `...' token. */ - cp_lexer_consume_token (parser->lexer); - expr_hi = - cp_parser_constant_expression (parser, - /*allow_non_constant_p=*/false, - NULL); - /* We don't need to emit warnings here, as the common code - will do this for us. */ - } - else - expr_hi = NULL_TREE; - - if (parser->in_switch_statement_p) - finish_case_label (expr, expr_hi); - else - error ("case label %qE not within a switch statement", expr); - } - break; - - case RID_DEFAULT: - /* Consume the `default' token. */ - cp_lexer_consume_token (parser->lexer); - - if (parser->in_switch_statement_p) - finish_case_label (NULL_TREE, NULL_TREE); - else - error ("case label not within a switch statement"); - break; - - default: - /* Anything else must be an ordinary label. */ - finish_label_stmt (cp_parser_identifier (parser)); - break; - } - - /* Require the `:' token. */ - cp_parser_require (parser, CPP_COLON, "`:'"); -} - -/* Parse an expression-statement. - - expression-statement: - expression [opt] ; - - Returns the new EXPR_STMT -- or NULL_TREE if the expression - statement consists of nothing more than an `;'. IN_STATEMENT_EXPR_P - indicates whether this expression-statement is part of an - expression statement. */ - -static tree -cp_parser_expression_statement (cp_parser* parser, tree in_statement_expr) -{ - tree statement = NULL_TREE; - - /* If the next token is a ';', then there is no expression - statement. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - statement = cp_parser_expression (parser, /*cast_p=*/false); - - /* Consume the final `;'. */ - cp_parser_consume_semicolon_at_end_of_statement (parser); - - if (in_statement_expr - && cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE)) - /* This is the final expression statement of a statement - expression. */ - statement = finish_stmt_expr_expr (statement, in_statement_expr); - else if (statement) - statement = finish_expr_stmt (statement); - else - finish_stmt (); - - return statement; -} - -/* Parse a compound-statement. - - compound-statement: - { statement-seq [opt] } - - Returns a tree representing the statement. */ - -static tree -cp_parser_compound_statement (cp_parser *parser, tree in_statement_expr, - /* APPLE LOCAL radar 5982990 */ - bool in_try, bool objc_sjlj_exceptions) -{ - tree compound_stmt; - - /* Consume the `{'. */ - if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'")) - return error_mark_node; - /* Begin the compound-statement. */ - compound_stmt = begin_compound_stmt (in_try ? BCS_TRY_BLOCK : 0); - /* APPLE LOCAL begin CW asm blocks */ - /* Maybe this is the body of an asm function, which has asm lines - following the decls. */ - if (iasm_state >= iasm_decls) - { - cp_token *token = cp_lexer_peek_token (parser->lexer); - iasm_in_decl = true; - if (token->u.value && IASM_SEE_OPCODE (TYPESPEC, token->u.value) == IDENTIFIER) - { - token->keyword = RID_MAX; - token->type = CPP_NAME; - } - cp_parser_iasm_declaration_seq_opt (parser); - iasm_in_decl = false; - iasm_state = iasm_asm; - inside_iasm_block = true; - iasm_kill_regs = true; - cp_parser_iasm_line_seq_opt (parser); - iasm_state = iasm_none; - iasm_end_block (); - } - else - /* APPLE LOCAL end CW asm blocks */ - /* Parse an (optional) statement-seq. */ - cp_parser_statement_seq_opt (parser, in_statement_expr); - /* APPLE LOCAL begin radar 5982990 */ - if (objc_sjlj_exceptions) - objc_mark_locals_volatile (NULL); - /* APPLE LOCAL end radar 5982990 */ - /* Finish the compound-statement. */ - finish_compound_stmt (compound_stmt); - /* Consume the `}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - - return compound_stmt; -} - -/* APPLE LOCAL begin CW asm blocks */ -static bool -cp_lexer_iasm_bol (cp_lexer* lexer) -{ - /* We can't use cp_lexer_peek_token here, as it will give errors for things like - 1st in MS-stype asm. */ - cp_token *token = lexer->next_token; - - return (token->flags & BOL) != 0; -} -/* APPLE LOCAL end CW asm blocks */ - -/* Parse an (optional) statement-seq. - - statement-seq: - statement - statement-seq [opt] statement */ - -static void -cp_parser_statement_seq_opt (cp_parser* parser, tree in_statement_expr) -{ - /* APPLE LOCAL begin omit calls to empty destructors 5559195 */ - tree class_type = DECL_CONTEXT (current_function_decl); - - bool determine_destructor_triviality = - DECL_DESTRUCTOR_P (current_function_decl) && class_type != NULL_TREE - && !CLASSTYPE_DESTRUCTOR_TRIVIALITY_FINAL (class_type); - - /* Assume that the destructor is trivial at first, and mark nontrivial if - any statement is parsed. */ - if (determine_destructor_triviality) - { - CLASSTYPE_HAS_NONTRIVIAL_DESTRUCTOR_BODY (class_type) = 0; - CLASSTYPE_DESTRUCTOR_TRIVIALITY_FINAL (class_type) = 1; - } - /* APPLE LOCAL end omit calls to empty destructors 5559195 */ - - /* Scan statements until there aren't any more. */ - while (true) - { - cp_token *token = cp_lexer_peek_token (parser->lexer); - - /* APPLE LOCAL begin ObjC++ 4185810 */ - /* If we're looking at a `}', then we've run out of - statements; the same is true if we have reached the end - of file, or have stumbled upon a stray 'else' or '@end'. */ - if (token->type == CPP_CLOSE_BRACE - || token->type == CPP_EOF - || token->type == CPP_PRAGMA_EOL - || (token->type == CPP_KEYWORD - && (token->keyword == RID_ELSE - || token->keyword == RID_AT_END))) - /* APPLE LOCAL end ObjC++ 4185810 */ - break; - - /* APPLE LOCAL begin omit calls to empty destructors 5559195 */ - if (determine_destructor_triviality) - CLASSTYPE_HAS_NONTRIVIAL_DESTRUCTOR_BODY (class_type) = 1; - /* APPLE LOCAL end omit calls to empty destructors 5559195 */ - - /* Parse the statement. */ - cp_parser_statement (parser, in_statement_expr, true); - - /* APPLE LOCAL begin CW asm blocks */ - if (flag_iasm_blocks - && iasm_state >= iasm_decls - && (cp_lexer_iasm_bol (parser->lexer) - || cp_lexer_next_token_is (parser->lexer, CPP_NAME))) - break; - /* APPLE LOCAL end CW asm blocks */ - } -} - -/* Parse a selection-statement. - - selection-statement: - if ( condition ) statement - if ( condition ) statement else statement - switch ( condition ) statement - - Returns the new IF_STMT or SWITCH_STMT. */ - -static tree -cp_parser_selection_statement (cp_parser* parser) -{ - cp_token *token; - enum rid keyword; - - /* Peek at the next token. */ - token = cp_parser_require (parser, CPP_KEYWORD, "selection-statement"); - - /* See what kind of keyword it is. */ - keyword = token->keyword; - switch (keyword) - { - case RID_IF: - case RID_SWITCH: - { - tree statement; - tree condition; - - /* Look for the `('. */ - if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - { - cp_parser_skip_to_end_of_statement (parser); - return error_mark_node; - } - - /* Begin the selection-statement. */ - if (keyword == RID_IF) - statement = begin_if_stmt (); - else - statement = begin_switch_stmt (); - - /* Parse the condition. */ - condition = cp_parser_condition (parser); - /* Look for the `)'. */ - if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - cp_parser_skip_to_closing_parenthesis (parser, true, false, - /*consume_paren=*/true); - - if (keyword == RID_IF) - { - /* Add the condition. */ - finish_if_stmt_cond (condition, statement); - - /* Parse the then-clause. */ - cp_parser_implicitly_scoped_statement (parser); - finish_then_clause (statement); - - /* If the next token is `else', parse the else-clause. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, - RID_ELSE)) - { - /* Consume the `else' keyword. */ - cp_lexer_consume_token (parser->lexer); - begin_else_clause (statement); - /* Parse the else-clause. */ - cp_parser_implicitly_scoped_statement (parser); - finish_else_clause (statement); - } - - /* Now we're all done with the if-statement. */ - finish_if_stmt (statement); - } - else - { - bool in_switch_statement_p; - unsigned char in_statement; - - /* Add the condition. */ - finish_switch_cond (condition, statement); - - /* Parse the body of the switch-statement. */ - in_switch_statement_p = parser->in_switch_statement_p; - in_statement = parser->in_statement; - parser->in_switch_statement_p = true; - parser->in_statement |= IN_SWITCH_STMT; - cp_parser_implicitly_scoped_statement (parser); - parser->in_switch_statement_p = in_switch_statement_p; - parser->in_statement = in_statement; - - /* Now we're all done with the switch-statement. */ - finish_switch_stmt (statement); - } - - return statement; - } - break; - - default: - cp_parser_error (parser, "expected selection-statement"); - return error_mark_node; - } -} - -/* Parse a condition. - - condition: - expression - type-specifier-seq declarator = assignment-expression - - GNU Extension: - - condition: - type-specifier-seq declarator asm-specification [opt] - attributes [opt] = assignment-expression - - Returns the expression that should be tested. */ - -static tree -cp_parser_condition (cp_parser* parser) -{ - cp_decl_specifier_seq type_specifiers; - const char *saved_message; - - /* Try the declaration first. */ - cp_parser_parse_tentatively (parser); - /* New types are not allowed in the type-specifier-seq for a - condition. */ - saved_message = parser->type_definition_forbidden_message; - parser->type_definition_forbidden_message - = "types may not be defined in conditions"; - /* Parse the type-specifier-seq. */ - cp_parser_type_specifier_seq (parser, /*is_condition==*/true, - &type_specifiers); - /* Restore the saved message. */ - parser->type_definition_forbidden_message = saved_message; - /* If all is well, we might be looking at a declaration. */ - if (!cp_parser_error_occurred (parser)) - { - tree decl; - tree asm_specification; - tree attributes; - cp_declarator *declarator; - tree initializer = NULL_TREE; - - /* Parse the declarator. */ - declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED, - /*ctor_dtor_or_conv_p=*/NULL, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - /* Parse the attributes. */ - attributes = cp_parser_attributes_opt (parser); - /* Parse the asm-specification. */ - asm_specification = cp_parser_asm_specification_opt (parser); - /* If the next token is not an `=', then we might still be - looking at an expression. For example: - - if (A(a).x) - - looks like a decl-specifier-seq and a declarator -- but then - there is no `=', so this is an expression. */ - cp_parser_require (parser, CPP_EQ, "`='"); - /* If we did see an `=', then we are looking at a declaration - for sure. */ - if (cp_parser_parse_definitely (parser)) - { - tree pushed_scope; - bool non_constant_p; - - /* Create the declaration. */ - decl = start_decl (declarator, &type_specifiers, - /*initialized_p=*/true, - attributes, /*prefix_attributes=*/NULL_TREE, - &pushed_scope); - /* Parse the assignment-expression. */ - initializer - = cp_parser_constant_expression (parser, - /*allow_non_constant_p=*/true, - &non_constant_p); - if (!non_constant_p) - initializer = fold_non_dependent_expr (initializer); - - /* Process the initializer. */ - cp_finish_decl (decl, - initializer, !non_constant_p, - asm_specification, - LOOKUP_ONLYCONVERTING); - - if (pushed_scope) - pop_scope (pushed_scope); - - return convert_from_reference (decl); - } - } - /* If we didn't even get past the declarator successfully, we are - definitely not looking at a declaration. */ - else - cp_parser_abort_tentative_parse (parser); - - /* Otherwise, we are looking at an expression. */ - return cp_parser_expression (parser, /*cast_p=*/false); -} - -/* APPLE LOCAL begin radar 4631818 */ -/* This routine looks for objective-c++'s foreach statement by scanning for-loop - header looking for either 1) 'for (type selector in...)' or 2) 'for (selector in...)' - where selector is already declared in outer scope. If it failed, it undoes the lexical - look-ahead and returns false. If it succeeded, it adds the 'selector' to the statement - list and returns true. At success, lexer points to token following the 'in' keyword. -*/ - -static bool -cp_parser_parse_foreach_stmt (cp_parser *parser) -{ - int decl_spec_declares_class_or_enum; - bool is_cv_qualifier; - tree type_spec; - cp_decl_specifier_seq decl_specs; - tree node; - cp_token *token; - bool is_legit_foreach = false; - cp_declarator *declarator; - - /* Exclude class/struct/enum type definition in for-loop header, which is - aparently legal in c++. Otherwise, it causes side-effect (type is enterred - in function's scope) when type is re-parsed. */ - token = cp_lexer_peek_token (parser->lexer); - if (cp_parser_token_is_class_key (token) || token->keyword == RID_ENUM) - return false; - - cp_parser_parse_tentatively (parser); - clear_decl_specs (&decl_specs); - type_spec - = cp_parser_type_specifier (parser, CP_PARSER_FLAGS_OPTIONAL, - &decl_specs, - /*is_declaration=*/true, - &decl_spec_declares_class_or_enum, - &is_cv_qualifier); - declarator - = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED, - NULL, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - if (declarator == cp_error_declarator) - { - cp_parser_abort_tentative_parse (parser); - return false; - } - - token = cp_lexer_peek_token (parser->lexer); - - node = token->u.value; - if (node && TREE_CODE (node) == IDENTIFIER_NODE - && node == ridpointers [(int) RID_IN]) - { - enum cpp_ttype nt = cp_lexer_peek_nth_token (parser->lexer, 2)->type; - switch (nt) - { - case CPP_NAME: - case CPP_OPEN_PAREN: - case CPP_MULT: - case CPP_PLUS: case CPP_PLUS_PLUS: - case CPP_MINUS: case CPP_MINUS_MINUS: - case CPP_OPEN_SQUARE: - is_legit_foreach = true; - default: - break; - } - } - if (is_legit_foreach) - { - tree pushed_scope = NULL; - tree decl; - if (type_spec) - { - /* we have: 'for (type selector in...)' */ - cp_parser_commit_to_tentative_parse (parser); - decl = start_decl (declarator, &decl_specs, - false /*is_initialized*/, - NULL_TREE /*attributes*/, - NULL_TREE /*prefix_attributes*/, - &pushed_scope); - /* APPLE LOCAL begin radar 5130983 */ - if (!decl || decl == error_mark_node) - { - error ("selector is undeclared"); - is_legit_foreach = false; - } - else - cp_finish_decl (decl, - NULL_TREE /*initializer*/, - false /*init_const_expr_p=*/, - NULL_TREE /*asm_specification*/, - 0 /*flags */); - } - else { - tree statement; - /* we have: 'for (selector in...)' */ - /* Parse it as an expression. */ - cp_parser_abort_tentative_parse (parser); - statement = cp_parser_expression (parser, /*cast_p=*/false); - add_stmt (statement); - } - /* APPLE LOCAL end radar 5130983 */ - /* Consume the 'in' token */ - cp_lexer_consume_token (parser->lexer); - } - else - cp_parser_abort_tentative_parse (parser); - return is_legit_foreach; -} -/* APPLE LOCAL end radar 4631818 */ - -/* APPLE LOCAL begin mainline */ -/* We check for a ) immediately followed by ; with no whitespacing - between. This is used to issue a warning for: - - while (...); - - and: - - for (...); - - as the semicolon is probably extraneous. - - On parse errors, the next token might not be a ), so do nothing in - that case. */ - -static void -check_empty_body (cp_parser* parser, const char* type) -{ - cp_token *token; - cp_token *close_paren; - expanded_location close_loc; - expanded_location semi_loc; - - close_paren = cp_lexer_peek_token (parser->lexer); - if (close_paren->type != CPP_CLOSE_PAREN) - return; - - close_loc = expand_location (close_paren->location); - token = cp_lexer_peek_nth_token (parser->lexer, 2); - - if (token->type != CPP_SEMICOLON - || (token->flags & PREV_WHITE)) - return; - - semi_loc = expand_location (token->location); - if (close_loc.line == semi_loc.line -#ifdef USE_MAPPED_LOCATION - && close_loc.column+1 == semi_loc.column -#endif - ) - warning (OPT_Wempty_body, - "suggest a space before %<;%> or explicit braces around empty " - "body in %<%s%> statement", - type); -} -/* APPLE LOCAL end mainline */ - -/* Parse an iteration-statement. - - iteration-statement: - while ( condition ) statement - do statement while ( expression ) ; - for ( for-init-statement condition [opt] ; expression [opt] ) - statement - - APPLE LOCAL begin for-fsf-4_4 3274130 5295549 - GNU extension: - - while attributes [opt] ( condition ) statement - do attributes [opt] statement while ( expression ) ; - for attributes [opt] - ( for-init-statement condition [opt] ; expression [opt] ) - statement - - APPLE LOCAL end for-fsf-4_4 3274130 5295549 - Returns the new WHILE_STMT, DO_STMT, or FOR_STMT. */ - -static tree -cp_parser_iteration_statement (cp_parser* parser) -{ - cp_token *token; - enum rid keyword; -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - tree statement, attributes; -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - unsigned char in_statement; - -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - /* Get the keyword at the start of the loop. */ -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - token = cp_parser_require (parser, CPP_KEYWORD, "iteration-statement"); - if (!token) - return error_mark_node; - - /* Remember whether or not we are already within an iteration - statement. */ - in_statement = parser->in_statement; - -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - /* Parse the attributes, if any. */ - attributes = cp_parser_attributes_opt (parser); - -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - /* See what kind of keyword it is. */ - keyword = token->keyword; - switch (keyword) - { - case RID_WHILE: - { - tree condition; - - /* Begin the while-statement. */ -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - statement = begin_while_stmt (attributes); -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - /* Look for the `('. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - /* Parse the condition. */ - condition = cp_parser_condition (parser); - finish_while_stmt_cond (condition, statement); - /* APPLE LOCAL mainline */ - check_empty_body (parser, "while"); - /* Look for the `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - /* Parse the dependent statement. */ - parser->in_statement = IN_ITERATION_STMT; - cp_parser_already_scoped_statement (parser); - parser->in_statement = in_statement; - /* We're done with the while-statement. */ - finish_while_stmt (statement); - } - break; - - case RID_DO: - { - tree expression; - - /* Begin the do-statement. */ -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - statement = begin_do_stmt (attributes); -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - /* Parse the body of the do-statement. */ - parser->in_statement = IN_ITERATION_STMT; - cp_parser_implicitly_scoped_statement (parser); - parser->in_statement = in_statement; - finish_do_body (statement); - /* Look for the `while' keyword. */ - cp_parser_require_keyword (parser, RID_WHILE, "`while'"); - /* Look for the `('. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - /* Parse the expression. */ - expression = cp_parser_expression (parser, /*cast_p=*/false); - /* We're done with the do-statement. */ - finish_do_stmt (expression, statement); - /* Look for the `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - /* Look for the `;'. */ - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); - } - break; - - case RID_FOR: - { - tree condition = NULL_TREE; - tree expression = NULL_TREE; - - /* Begin the for-statement. */ -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - statement = begin_for_stmt (attributes); -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - /* Look for the `('. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - /* APPLE LOCAL begin radar 4631818 */ - if (c_dialect_objc () - && cp_parser_parse_foreach_stmt (parser)) - { - objc_foreach_stmt (parser, statement); - break; - } - /* APPLE LOCAL end radar 4631818 */ - /* Parse the initialization. */ - cp_parser_for_init_statement (parser); - finish_for_init_stmt (statement); - - /* If there's a condition, process it. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - condition = cp_parser_condition (parser); - finish_for_cond (condition, statement); - /* Look for the `;'. */ - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); - - /* If there's an expression, process it. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)) - expression = cp_parser_expression (parser, /*cast_p=*/false); - finish_for_expr (expression, statement); - /* APPLE LOCAL mainline */ - check_empty_body (parser, "for"); - /* Look for the `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - /* Parse the body of the for-statement. */ - parser->in_statement = IN_ITERATION_STMT; - cp_parser_already_scoped_statement (parser); - parser->in_statement = in_statement; - - /* We're done with the for-statement. */ - finish_for_stmt (statement); - } - break; - - default: - cp_parser_error (parser, "expected iteration-statement"); - statement = error_mark_node; - break; - } - - return statement; -} - -/* Parse a for-init-statement. - - for-init-statement: - expression-statement - simple-declaration */ - -static void -cp_parser_for_init_statement (cp_parser* parser) -{ - /* If the next token is a `;', then we have an empty - expression-statement. Grammatically, this is also a - simple-declaration, but an invalid one, because it does not - declare anything. Therefore, if we did not handle this case - specially, we would issue an error message about an invalid - declaration. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - { - /* We're going to speculatively look for a declaration, falling back - to an expression, if necessary. */ - cp_parser_parse_tentatively (parser); - /* Parse the declaration. */ - cp_parser_simple_declaration (parser, - /*function_definition_allowed_p=*/false); - /* If the tentative parse failed, then we shall need to look for an - expression-statement. */ - if (cp_parser_parse_definitely (parser)) - return; - } - - cp_parser_expression_statement (parser, false); -} - -/* Parse a jump-statement. - - jump-statement: - break ; - continue ; - return expression [opt] ; - goto identifier ; - - GNU extension: - - jump-statement: - goto * expression ; - - Returns the new BREAK_STMT, CONTINUE_STMT, RETURN_EXPR, or GOTO_EXPR. */ - -static tree -cp_parser_jump_statement (cp_parser* parser) -{ - tree statement = error_mark_node; - cp_token *token; - enum rid keyword; - - /* Peek at the next token. */ - token = cp_parser_require (parser, CPP_KEYWORD, "jump-statement"); - if (!token) - return error_mark_node; - - /* See what kind of keyword it is. */ - keyword = token->keyword; - switch (keyword) - { - case RID_BREAK: - switch (parser->in_statement) - { - case 0: - error ("break statement not within loop or switch"); - break; - default: - gcc_assert ((parser->in_statement & IN_SWITCH_STMT) - || parser->in_statement == IN_ITERATION_STMT); - statement = finish_break_stmt (); - break; - case IN_OMP_BLOCK: - error ("invalid exit from OpenMP structured block"); - break; - case IN_OMP_FOR: - error ("break statement used with OpenMP for loop"); - break; - } - cp_parser_require (parser, CPP_SEMICOLON, "%<;%>"); - break; - - case RID_CONTINUE: - switch (parser->in_statement & ~IN_SWITCH_STMT) - { - case 0: - error ("continue statement not within a loop"); - break; - case IN_ITERATION_STMT: - case IN_OMP_FOR: - statement = finish_continue_stmt (); - break; - case IN_OMP_BLOCK: - error ("invalid exit from OpenMP structured block"); - break; - default: - gcc_unreachable (); - } - cp_parser_require (parser, CPP_SEMICOLON, "%<;%>"); - break; - - case RID_RETURN: - { - tree expr; - - /* If the next token is a `;', then there is no - expression. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - expr = cp_parser_expression (parser, /*cast_p=*/false); - else - expr = NULL_TREE; - /* Build the return-statement. */ - statement = finish_return_stmt (expr); - /* Look for the final `;'. */ - cp_parser_require (parser, CPP_SEMICOLON, "%<;%>"); - } - break; - - case RID_GOTO: - /* APPLE LOCAL begin blocks 6040305 (cb) */ - if (cur_block) - error ("goto not allowed in block literal"); - /* APPLE LOCAL end blocks 6040305 (cb) */ - /* Create the goto-statement. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_MULT)) - { - /* Issue a warning about this use of a GNU extension. */ - if (pedantic) - pedwarn ("ISO C++ forbids computed gotos"); - /* Consume the '*' token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the dependent expression. */ - finish_goto_stmt (cp_parser_expression (parser, /*cast_p=*/false)); - } - else - finish_goto_stmt (cp_parser_identifier (parser)); - /* Look for the final `;'. */ - cp_parser_require (parser, CPP_SEMICOLON, "%<;%>"); - break; - - default: - cp_parser_error (parser, "expected jump-statement"); - break; - } - - return statement; -} - -/* Parse a declaration-statement. - - declaration-statement: - block-declaration */ - -static void -cp_parser_declaration_statement (cp_parser* parser) -{ - void *p; - - /* Get the high-water mark for the DECLARATOR_OBSTACK. */ - p = obstack_alloc (&declarator_obstack, 0); - - /* Parse the block-declaration. */ - cp_parser_block_declaration (parser, /*statement_p=*/true); - - /* Free any declarators allocated. */ - obstack_free (&declarator_obstack, p); - - /* Finish off the statement. */ - finish_stmt (); -} - -/* Some dependent statements (like `if (cond) statement'), are - implicitly in their own scope. In other words, if the statement is - a single statement (as opposed to a compound-statement), it is - none-the-less treated as if it were enclosed in braces. Any - declarations appearing in the dependent statement are out of scope - after control passes that point. This function parses a statement, - but ensures that is in its own scope, even if it is not a - compound-statement. - - Returns the new statement. */ - -static tree -cp_parser_implicitly_scoped_statement (cp_parser* parser) -{ - tree statement; - - /* Mark if () ; with a special NOP_EXPR. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) - { - cp_lexer_consume_token (parser->lexer); - statement = add_stmt (build_empty_stmt ()); - } - /* if a compound is opened, we simply parse the statement directly. */ - else if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) - /* APPLE LOCAL radar 5982990 */ - statement = cp_parser_compound_statement (parser, NULL, false, false); - /* If the token is not a `{', then we must take special action. */ - else - { - /* Create a compound-statement. */ - statement = begin_compound_stmt (0); - /* Parse the dependent-statement. */ - cp_parser_statement (parser, NULL_TREE, false); - /* Finish the dummy compound-statement. */ - finish_compound_stmt (statement); - } - - /* Return the statement. */ - return statement; -} - -/* For some dependent statements (like `while (cond) statement'), we - have already created a scope. Therefore, even if the dependent - statement is a compound-statement, we do not want to create another - scope. */ - -static void -cp_parser_already_scoped_statement (cp_parser* parser) -{ - /* If the token is a `{', then we must take special action. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)) - cp_parser_statement (parser, NULL_TREE, false); - else - { - /* Avoid calling cp_parser_compound_statement, so that we - don't create a new scope. Do everything else by hand. */ - cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"); - cp_parser_statement_seq_opt (parser, NULL_TREE); - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - } -} - -/* Declarations [gram.dcl.dcl] */ - -/* Parse an optional declaration-sequence. - - declaration-seq: - declaration - declaration-seq declaration */ - -static void -cp_parser_declaration_seq_opt (cp_parser* parser) -{ - while (true) - { - cp_token *token; - - token = cp_lexer_peek_token (parser->lexer); - - if (token->type == CPP_CLOSE_BRACE - || token->type == CPP_EOF - || token->type == CPP_PRAGMA_EOL) - break; - - if (token->type == CPP_SEMICOLON) - { - /* A declaration consisting of a single semicolon is - invalid. Allow it unless we're being pedantic. */ - cp_lexer_consume_token (parser->lexer); - if (pedantic && !in_system_header) - pedwarn ("extra %<;%>"); - continue; - } - - /* If we're entering or exiting a region that's implicitly - extern "C", modify the lang context appropriately. */ - if (!parser->implicit_extern_c && token->implicit_extern_c) - { - push_lang_context (lang_name_c); - parser->implicit_extern_c = true; - } - else if (parser->implicit_extern_c && !token->implicit_extern_c) - { - pop_lang_context (); - parser->implicit_extern_c = false; - } - - if (token->type == CPP_PRAGMA) - { - /* A top-level declaration can consist solely of a #pragma. - A nested declaration cannot, so this is done here and not - in cp_parser_declaration. (A #pragma at block scope is - handled in cp_parser_statement.) */ - cp_parser_pragma (parser, pragma_external); - continue; - } - - /* Parse the declaration itself. */ - cp_parser_declaration (parser); - } -} - -/* APPLE LOCAL begin radar 4548636 */ -static bool -/* This routine is called when lexer has seen an '__attribute__' token. - It does look-ahead to see of __attribute__ list declaration is followed - by an objective-c at_keyword. If so, it returns true. This is to - disambiguate use of attribute before types and before objective-c's - @interface declaration. */ - -objc_attr_follwed_by_at_keyword (cp_parser* parser) -{ - cp_token token1; - tree attributes = NULL_TREE; - cp_lexer_save_tokens (parser->lexer); - cp_parser_objc_maybe_attributes (parser, &attributes); - gcc_assert (attributes); - token1 = *cp_lexer_peek_token (parser->lexer); - cp_lexer_rollback_tokens (parser->lexer); - return OBJC_IS_AT_KEYWORD (token1.keyword); -} -/* APPLE LOCAL end radar 4548636 */ - -/* Parse a declaration. - - declaration: - block-declaration - function-definition - template-declaration - explicit-instantiation - explicit-specialization - linkage-specification - namespace-definition - - GNU extension: - - declaration: - __extension__ declaration */ - -static void -cp_parser_declaration (cp_parser* parser) -{ - cp_token token1; - cp_token token2; - int saved_pedantic; - void *p; - - /* Check for the `__extension__' keyword. */ - if (cp_parser_extension_opt (parser, &saved_pedantic)) - { - /* Parse the qualified declaration. */ - cp_parser_declaration (parser); - /* Restore the PEDANTIC flag. */ - pedantic = saved_pedantic; - - return; - } - - /* Try to figure out what kind of declaration is present. */ - token1 = *cp_lexer_peek_token (parser->lexer); - - if (token1.type != CPP_EOF) - token2 = *cp_lexer_peek_nth_token (parser->lexer, 2); - else - { - token2.type = CPP_EOF; - token2.keyword = RID_MAX; - } - - /* Get the high-water mark for the DECLARATOR_OBSTACK. */ - p = obstack_alloc (&declarator_obstack, 0); - - /* If the next token is `extern' and the following token is a string - literal, then we have a linkage specification. */ - if (token1.keyword == RID_EXTERN - && cp_parser_is_string_literal (&token2)) - cp_parser_linkage_specification (parser); - /* If the next token is `template', then we have either a template - declaration, an explicit instantiation, or an explicit - specialization. */ - else if (token1.keyword == RID_TEMPLATE) - { - /* `template <>' indicates a template specialization. */ - if (token2.type == CPP_LESS - && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER) - cp_parser_explicit_specialization (parser); - /* `template <' indicates a template declaration. */ - else if (token2.type == CPP_LESS) - cp_parser_template_declaration (parser, /*member_p=*/false); - /* Anything else must be an explicit instantiation. */ - else - cp_parser_explicit_instantiation (parser); - } - /* If the next token is `export', then we have a template - declaration. */ - else if (token1.keyword == RID_EXPORT) - cp_parser_template_declaration (parser, /*member_p=*/false); - /* If the next token is `extern', 'static' or 'inline' and the one - after that is `template', we have a GNU extended explicit - instantiation directive. */ - else if (cp_parser_allow_gnu_extensions_p (parser) - && (token1.keyword == RID_EXTERN - || token1.keyword == RID_STATIC - || token1.keyword == RID_INLINE) - && token2.keyword == RID_TEMPLATE) - cp_parser_explicit_instantiation (parser); - /* If the next token is `namespace', check for a named or unnamed - namespace definition. */ - else if (token1.keyword == RID_NAMESPACE - && (/* A named namespace definition. */ - (token2.type == CPP_NAME - && (cp_lexer_peek_nth_token (parser->lexer, 3)->type - != CPP_EQ)) - /* An unnamed namespace definition. */ - || token2.type == CPP_OPEN_BRACE - || token2.keyword == RID_ATTRIBUTE)) - cp_parser_namespace_definition (parser); - /* Objective-C++ declaration/definition. */ - /* APPLE LOCAL begin radar 4548636 */ - else if (c_dialect_objc () - && (OBJC_IS_AT_KEYWORD (token1.keyword) - || (token1.keyword == RID_ATTRIBUTE - && objc_attr_follwed_by_at_keyword (parser)))) - /* APPLE LOCAL end radar 4548636 */ - cp_parser_objc_declaration (parser); - /* We must have either a block declaration or a function - definition. */ - else - /* Try to parse a block-declaration, or a function-definition. */ - cp_parser_block_declaration (parser, /*statement_p=*/false); - - /* Free any declarators allocated. */ - obstack_free (&declarator_obstack, p); -} - -/* Parse a block-declaration. - - block-declaration: - simple-declaration - asm-definition - namespace-alias-definition - using-declaration - using-directive - - GNU Extension: - - block-declaration: - __extension__ block-declaration - label-declaration - - If STATEMENT_P is TRUE, then this block-declaration is occurring as - part of a declaration-statement. */ - -static void -cp_parser_block_declaration (cp_parser *parser, - bool statement_p) -{ - cp_token *token1; - int saved_pedantic; - - /* Check for the `__extension__' keyword. */ - if (cp_parser_extension_opt (parser, &saved_pedantic)) - { - /* Parse the qualified declaration. */ - cp_parser_block_declaration (parser, statement_p); - /* Restore the PEDANTIC flag. */ - pedantic = saved_pedantic; - - return; - } - - /* Peek at the next token to figure out which kind of declaration is - present. */ - token1 = cp_lexer_peek_token (parser->lexer); - - /* If the next keyword is `asm', we have an asm-definition. */ - if (token1->keyword == RID_ASM) - { - if (statement_p) - cp_parser_commit_to_tentative_parse (parser); - /* APPLE LOCAL CW asm blocks */ - cp_parser_asm_definition (parser, statement_p); - } - /* If the next keyword is `namespace', we have a - namespace-alias-definition. */ - else if (token1->keyword == RID_NAMESPACE) - cp_parser_namespace_alias_definition (parser); - /* If the next keyword is `using', we have either a - using-declaration or a using-directive. */ - else if (token1->keyword == RID_USING) - { - cp_token *token2; - - if (statement_p) - cp_parser_commit_to_tentative_parse (parser); - /* If the token after `using' is `namespace', then we have a - using-directive. */ - token2 = cp_lexer_peek_nth_token (parser->lexer, 2); - if (token2->keyword == RID_NAMESPACE) - cp_parser_using_directive (parser); - /* Otherwise, it's a using-declaration. */ - else - cp_parser_using_declaration (parser, - /*access_declaration_p=*/false); - } - /* If the next keyword is `__label__' we have a label declaration. */ - else if (token1->keyword == RID_LABEL) - { - if (statement_p) - cp_parser_commit_to_tentative_parse (parser); - cp_parser_label_declaration (parser); - } - /* Anything else must be a simple-declaration. */ - else - cp_parser_simple_declaration (parser, !statement_p); -} - -/* Parse a simple-declaration. - - simple-declaration: - decl-specifier-seq [opt] init-declarator-list [opt] ; - - init-declarator-list: - init-declarator - init-declarator-list , init-declarator - - If FUNCTION_DEFINITION_ALLOWED_P is TRUE, then we also recognize a - function-definition as a simple-declaration. */ - -static void -cp_parser_simple_declaration (cp_parser* parser, - bool function_definition_allowed_p) -{ - cp_decl_specifier_seq decl_specifiers; - int declares_class_or_enum; - bool saw_declarator; - - /* Defer access checks until we know what is being declared; the - checks for names appearing in the decl-specifier-seq should be - done as if we were in the scope of the thing being declared. */ - push_deferring_access_checks (dk_deferred); - - /* Parse the decl-specifier-seq. We have to keep track of whether - or not the decl-specifier-seq declares a named class or - enumeration type, since that is the only case in which the - init-declarator-list is allowed to be empty. - - [dcl.dcl] - - In a simple-declaration, the optional init-declarator-list can be - omitted only when declaring a class or enumeration, that is when - the decl-specifier-seq contains either a class-specifier, an - elaborated-type-specifier, or an enum-specifier. */ - cp_parser_decl_specifier_seq (parser, - CP_PARSER_FLAGS_OPTIONAL, - &decl_specifiers, - &declares_class_or_enum); - /* We no longer need to defer access checks. */ - stop_deferring_access_checks (); - - /* In a block scope, a valid declaration must always have a - decl-specifier-seq. By not trying to parse declarators, we can - resolve the declaration/expression ambiguity more quickly. */ - if (!function_definition_allowed_p - && !decl_specifiers.any_specifiers_p) - { - /* APPLE LOCAL begin CW asm blocks */ - /* We might have seen an asm opcode, and it's time to switch to - asm instruction handling. */ - if (flag_iasm_blocks && iasm_state >= iasm_decls) - return; - /* APPLE LOCAL end CW asm blocks */ - - cp_parser_error (parser, "expected declaration"); - goto done; - } - - /* If the next two tokens are both identifiers, the code is - erroneous. The usual cause of this situation is code like: - - T t; - - where "T" should name a type -- but does not. */ - if (!decl_specifiers.type - && cp_parser_parse_and_diagnose_invalid_type_name (parser)) - { - /* If parsing tentatively, we should commit; we really are - looking at a declaration. */ - cp_parser_commit_to_tentative_parse (parser); - /* Give up. */ - goto done; - } - - /* If we have seen at least one decl-specifier, and the next token - is not a parenthesis, then we must be looking at a declaration. - (After "int (" we might be looking at a functional cast.) */ - if (decl_specifiers.any_specifiers_p - && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)) - cp_parser_commit_to_tentative_parse (parser); - - /* Keep going until we hit the `;' at the end of the simple - declaration. */ - saw_declarator = false; - while (cp_lexer_next_token_is_not (parser->lexer, - CPP_SEMICOLON)) - { - cp_token *token; - bool function_definition_p; - tree decl; - - if (saw_declarator) - { - /* If we are processing next declarator, coma is expected */ - token = cp_lexer_peek_token (parser->lexer); - gcc_assert (token->type == CPP_COMMA); - cp_lexer_consume_token (parser->lexer); - } - else - saw_declarator = true; - - /* Parse the init-declarator. */ - decl = cp_parser_init_declarator (parser, &decl_specifiers, - /*checks=*/NULL, - function_definition_allowed_p, - /*member_p=*/false, - declares_class_or_enum, - &function_definition_p); - /* If an error occurred while parsing tentatively, exit quickly. - (That usually happens when in the body of a function; each - statement is treated as a declaration-statement until proven - otherwise.) */ - if (cp_parser_error_occurred (parser)) - goto done; - /* Handle function definitions specially. */ - if (function_definition_p) - { - /* If the next token is a `,', then we are probably - processing something like: - - void f() {}, *p; - - which is erroneous. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) - error ("mixing declarations and function-definitions is forbidden"); - /* Otherwise, we're done with the list of declarators. */ - else - { - pop_deferring_access_checks (); - return; - } - } - /* The next token should be either a `,' or a `;'. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's a `,', there are more declarators to come. */ - if (token->type == CPP_COMMA) - /* will be consumed next time around */; - /* If it's a `;', we are done. */ - else if (token->type == CPP_SEMICOLON) - break; - /* Anything else is an error. */ - else - { - /* If we have already issued an error message we don't need - to issue another one. */ - if (decl != error_mark_node - || cp_parser_uncommitted_to_tentative_parse_p (parser)) - cp_parser_error (parser, "expected %<,%> or %<;%>"); - /* Skip tokens until we reach 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); - goto done; - } - /* After the first time around, a function-definition is not - allowed -- even if it was OK at first. For example: - - int i, f() {} - - is not valid. */ - function_definition_allowed_p = false; - } - - /* Issue an error message if no declarators are present, and the - decl-specifier-seq does not itself declare a class or - enumeration. */ - if (!saw_declarator) - { - if (cp_parser_declares_only_class_p (parser)) - shadow_tag (&decl_specifiers); - /* Perform any deferred access checks. */ - perform_deferred_access_checks (); - } - - /* Consume the `;'. */ - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); - - /* APPLE LOCAL begin CW asm blocks */ - if (flag_iasm_blocks) - iasm_in_decl = false; - /* APPLE LOCAL end CW asm blocks */ - - done: - pop_deferring_access_checks (); -} - -/* Parse a decl-specifier-seq. - - decl-specifier-seq: - decl-specifier-seq [opt] decl-specifier - - decl-specifier: - storage-class-specifier - type-specifier - function-specifier - friend - typedef - - GNU Extension: - - decl-specifier: - attributes - - Set *DECL_SPECS to a representation of the decl-specifier-seq. - - The parser flags FLAGS is used to control type-specifier parsing. - - *DECLARES_CLASS_OR_ENUM is set to the bitwise or of the following - flags: - - 1: one of the decl-specifiers is an elaborated-type-specifier - (i.e., a type declaration) - 2: one of the decl-specifiers is an enum-specifier or a - class-specifier (i.e., a type definition) - - */ - -static void -cp_parser_decl_specifier_seq (cp_parser* parser, - cp_parser_flags flags, - cp_decl_specifier_seq *decl_specs, - int* declares_class_or_enum) -{ - bool constructor_possible_p = !parser->in_declarator_p; - - /* Clear DECL_SPECS. */ - clear_decl_specs (decl_specs); - - /* Assume no class or enumeration type is declared. */ - *declares_class_or_enum = 0; - - /* Keep reading specifiers until there are no more to read. */ - while (true) - { - bool constructor_p; - bool found_decl_spec; - cp_token *token; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Handle attributes. */ - if (token->keyword == RID_ATTRIBUTE) - { - /* Parse the attributes. */ - decl_specs->attributes - = chainon (decl_specs->attributes, - cp_parser_attributes_opt (parser)); - continue; - } - /* Assume we will find a decl-specifier keyword. */ - found_decl_spec = true; - /* If the next token is an appropriate keyword, we can simply - add it to the list. */ - switch (token->keyword) - { - /* decl-specifier: - friend */ - case RID_FRIEND: - if (!at_class_scope_p ()) - { - error ("%<friend%> used outside of class"); - cp_lexer_purge_token (parser->lexer); - } - else - { - ++decl_specs->specs[(int) ds_friend]; - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - } - break; - - /* function-specifier: - inline - virtual - explicit */ - case RID_INLINE: - case RID_VIRTUAL: - case RID_EXPLICIT: - cp_parser_function_specifier_opt (parser, decl_specs); - break; - - /* decl-specifier: - typedef */ - case RID_TYPEDEF: - ++decl_specs->specs[(int) ds_typedef]; - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - /* A constructor declarator cannot appear in a typedef. */ - constructor_possible_p = false; - /* The "typedef" keyword can only occur in a declaration; we - may as well commit at this point. */ - cp_parser_commit_to_tentative_parse (parser); - - if (decl_specs->storage_class != sc_none) - decl_specs->conflicting_specifiers_p = true; - break; - - /* storage-class-specifier: - auto - register - static - extern - mutable - - GNU Extension: - thread */ - case RID_AUTO: - case RID_REGISTER: - case RID_STATIC: - case RID_EXTERN: - case RID_MUTABLE: - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - cp_parser_set_storage_class (parser, decl_specs, token->keyword); - break; - case RID_THREAD: - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - ++decl_specs->specs[(int) ds_thread]; - break; - - /* APPLE LOCAL begin CW asm blocks */ - /* If we ever get here, we must be in CW asm mode. */ - case RID_ASM: - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - ++decl_specs->specs[(int) ds_iasm_asm]; - break; - /* APPLE LOCAL end CW asm blocks */ - - default: - /* We did not yet find a decl-specifier yet. */ - found_decl_spec = false; - break; - } - - /* Constructors are a special case. The `S' in `S()' is not a - decl-specifier; it is the beginning of the declarator. */ - constructor_p - = (!found_decl_spec - && constructor_possible_p - && (cp_parser_constructor_declarator_p - (parser, decl_specs->specs[(int) ds_friend] != 0))); - - /* If we don't have a DECL_SPEC yet, then we must be looking at - a type-specifier. */ - if (!found_decl_spec && !constructor_p) - { - int decl_spec_declares_class_or_enum; - bool is_cv_qualifier; - tree type_spec; - - type_spec - = cp_parser_type_specifier (parser, flags, - decl_specs, - /*is_declaration=*/true, - &decl_spec_declares_class_or_enum, - &is_cv_qualifier); - - *declares_class_or_enum |= decl_spec_declares_class_or_enum; - - /* If this type-specifier referenced a user-defined type - (a typedef, class-name, etc.), then we can't allow any - more such type-specifiers henceforth. - - [dcl.spec] - - The longest sequence of decl-specifiers that could - possibly be a type name is taken as the - decl-specifier-seq of a declaration. The sequence shall - be self-consistent as described below. - - [dcl.type] - - As a general rule, at most one type-specifier is allowed - in the complete decl-specifier-seq of a declaration. The - only exceptions are the following: - - -- const or volatile can be combined with any other - type-specifier. - - -- signed or unsigned can be combined with char, long, - short, or int. - - -- .. - - Example: - - typedef char* Pc; - void g (const int Pc); - - Here, Pc is *not* part of the decl-specifier seq; it's - the declarator. Therefore, once we see a type-specifier - (other than a cv-qualifier), we forbid any additional - user-defined types. We *do* still allow things like `int - int' to be considered a decl-specifier-seq, and issue the - error message later. */ - if (type_spec && !is_cv_qualifier) - flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES; - /* A constructor declarator cannot follow a type-specifier. */ - if (type_spec) - { - constructor_possible_p = false; - found_decl_spec = true; - } - } - - /* If we still do not have a DECL_SPEC, then there are no more - decl-specifiers. */ - if (!found_decl_spec) - break; - - decl_specs->any_specifiers_p = true; - /* After we see one decl-specifier, further decl-specifiers are - always optional. */ - flags |= CP_PARSER_FLAGS_OPTIONAL; - } - - cp_parser_check_decl_spec (decl_specs); - - /* Don't allow a friend specifier with a class definition. */ - if (decl_specs->specs[(int) ds_friend] != 0 - && (*declares_class_or_enum & 2)) - error ("class definition may not be declared a friend"); -} - -/* Parse an (optional) storage-class-specifier. - - storage-class-specifier: - auto - register - static - extern - mutable - - GNU Extension: - - storage-class-specifier: - thread - - Returns an IDENTIFIER_NODE corresponding to the keyword used. */ - -static tree -cp_parser_storage_class_specifier_opt (cp_parser* parser) -{ - switch (cp_lexer_peek_token (parser->lexer)->keyword) - { - case RID_AUTO: - case RID_REGISTER: - case RID_STATIC: - case RID_EXTERN: - case RID_MUTABLE: - case RID_THREAD: - /* APPLE LOCAL begin CW asm blocks */ - /* If we ever get here, we must be in CW asm mode. */ - case RID_ASM: - /* APPLE LOCAL end CW asm blocks */ - /* Consume the token. */ - return cp_lexer_consume_token (parser->lexer)->u.value; - - default: - return NULL_TREE; - } -} - -/* Parse an (optional) function-specifier. - - function-specifier: - inline - virtual - explicit - - Returns an IDENTIFIER_NODE corresponding to the keyword used. - Updates DECL_SPECS, if it is non-NULL. */ - -static tree -cp_parser_function_specifier_opt (cp_parser* parser, - cp_decl_specifier_seq *decl_specs) -{ - switch (cp_lexer_peek_token (parser->lexer)->keyword) - { - case RID_INLINE: - if (decl_specs) - ++decl_specs->specs[(int) ds_inline]; - break; - - case RID_VIRTUAL: - /* 14.5.2.3 [temp.mem] - - A member function template shall not be virtual. */ - if (PROCESSING_REAL_TEMPLATE_DECL_P ()) - error ("templates may not be %<virtual%>"); - else if (decl_specs) - ++decl_specs->specs[(int) ds_virtual]; - break; - - case RID_EXPLICIT: - if (decl_specs) - ++decl_specs->specs[(int) ds_explicit]; - break; - - default: - return NULL_TREE; - } - - /* Consume the token. */ - return cp_lexer_consume_token (parser->lexer)->u.value; -} - -/* Parse a linkage-specification. - - linkage-specification: - extern string-literal { declaration-seq [opt] } - extern string-literal declaration */ - -static void -cp_parser_linkage_specification (cp_parser* parser) -{ - tree linkage; - - /* Look for the `extern' keyword. */ - cp_parser_require_keyword (parser, RID_EXTERN, "`extern'"); - - /* Look for the string-literal. */ - linkage = cp_parser_string_literal (parser, false, false); - - /* Transform the literal into an identifier. If the literal is a - wide-character string, or contains embedded NULs, then we can't - handle it as the user wants. */ - if (strlen (TREE_STRING_POINTER (linkage)) - != (size_t) (TREE_STRING_LENGTH (linkage) - 1)) - { - cp_parser_error (parser, "invalid linkage-specification"); - /* Assume C++ linkage. */ - linkage = lang_name_cplusplus; - } - else - linkage = get_identifier (TREE_STRING_POINTER (linkage)); - - /* We're now using the new linkage. */ - push_lang_context (linkage); - - /* If the next token is a `{', then we're using the first - production. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) - { - /* Consume the `{' token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the declarations. */ - cp_parser_declaration_seq_opt (parser); - /* Look for the closing `}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - } - /* Otherwise, there's just one declaration. */ - else - { - bool saved_in_unbraced_linkage_specification_p; - - saved_in_unbraced_linkage_specification_p - = parser->in_unbraced_linkage_specification_p; - parser->in_unbraced_linkage_specification_p = true; - cp_parser_declaration (parser); - parser->in_unbraced_linkage_specification_p - = saved_in_unbraced_linkage_specification_p; - } - - /* We're done with the linkage-specification. */ - pop_lang_context (); -} - -/* Special member functions [gram.special] */ - -/* Parse a conversion-function-id. - - conversion-function-id: - operator conversion-type-id - - Returns an IDENTIFIER_NODE representing the operator. */ - -static tree -cp_parser_conversion_function_id (cp_parser* parser) -{ - tree type; - tree saved_scope; - tree saved_qualifying_scope; - tree saved_object_scope; - tree pushed_scope = NULL_TREE; - - /* Look for the `operator' token. */ - if (!cp_parser_require_keyword (parser, RID_OPERATOR, "`operator'")) - return error_mark_node; - /* When we parse the conversion-type-id, the current scope will be - reset. However, we need that information in able to look up the - conversion function later, so we save it here. */ - saved_scope = parser->scope; - saved_qualifying_scope = parser->qualifying_scope; - saved_object_scope = parser->object_scope; - /* We must enter the scope of the class so that the names of - entities declared within the class are available in the - conversion-type-id. For example, consider: - - struct S { - typedef int I; - operator I(); - }; - - S::operator I() { ... } - - In order to see that `I' is a type-name in the definition, we - must be in the scope of `S'. */ - if (saved_scope) - pushed_scope = push_scope (saved_scope); - /* Parse the conversion-type-id. */ - type = cp_parser_conversion_type_id (parser); - /* Leave the scope of the class, if any. */ - if (pushed_scope) - pop_scope (pushed_scope); - /* Restore the saved scope. */ - parser->scope = saved_scope; - parser->qualifying_scope = saved_qualifying_scope; - parser->object_scope = saved_object_scope; - /* If the TYPE is invalid, indicate failure. */ - if (type == error_mark_node) - return error_mark_node; - return mangle_conv_op_name_for_type (type); -} - -/* Parse a conversion-type-id: - - conversion-type-id: - type-specifier-seq conversion-declarator [opt] - - Returns the TYPE specified. */ - -static tree -cp_parser_conversion_type_id (cp_parser* parser) -{ - tree attributes; - cp_decl_specifier_seq type_specifiers; - cp_declarator *declarator; - tree type_specified; - - /* Parse the attributes. */ - attributes = cp_parser_attributes_opt (parser); - /* Parse the type-specifiers. */ - cp_parser_type_specifier_seq (parser, /*is_condition=*/false, - &type_specifiers); - /* If that didn't work, stop. */ - if (type_specifiers.type == error_mark_node) - return error_mark_node; - /* Parse the conversion-declarator. */ - declarator = cp_parser_conversion_declarator_opt (parser); - - type_specified = grokdeclarator (declarator, &type_specifiers, TYPENAME, - /*initialized=*/0, &attributes); - if (attributes) - cplus_decl_attributes (&type_specified, attributes, /*flags=*/0); - return type_specified; -} - -/* Parse an (optional) conversion-declarator. - - conversion-declarator: - ptr-operator conversion-declarator [opt] - - */ - -static cp_declarator * -cp_parser_conversion_declarator_opt (cp_parser* parser) -{ - enum tree_code code; - tree class_type; - cp_cv_quals cv_quals; - - /* We don't know if there's a ptr-operator next, or not. */ - cp_parser_parse_tentatively (parser); - /* Try the ptr-operator. */ - code = cp_parser_ptr_operator (parser, &class_type, &cv_quals); - /* If it worked, look for more conversion-declarators. */ - if (cp_parser_parse_definitely (parser)) - { - cp_declarator *declarator; - - /* Parse another optional declarator. */ - declarator = cp_parser_conversion_declarator_opt (parser); - - /* Create the representation of the declarator. */ - if (class_type) - declarator = make_ptrmem_declarator (cv_quals, class_type, - declarator); - else if (code == INDIRECT_REF) - declarator = make_pointer_declarator (cv_quals, declarator); - else - declarator = make_reference_declarator (cv_quals, declarator); - - return declarator; - } - - return NULL; -} - -/* Parse an (optional) ctor-initializer. - - ctor-initializer: - : mem-initializer-list - - Returns TRUE iff the ctor-initializer was actually present. */ - -static bool -cp_parser_ctor_initializer_opt (cp_parser* parser) -{ - /* If the next token is not a `:', then there is no - ctor-initializer. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)) - { - /* Do default initialization of any bases and members. */ - if (DECL_CONSTRUCTOR_P (current_function_decl)) - finish_mem_initializers (NULL_TREE); - - return false; - } - - /* Consume the `:' token. */ - cp_lexer_consume_token (parser->lexer); - /* And the mem-initializer-list. */ - cp_parser_mem_initializer_list (parser); - - return true; -} - -/* Parse a mem-initializer-list. - - mem-initializer-list: - mem-initializer - mem-initializer , mem-initializer-list */ - -static void -cp_parser_mem_initializer_list (cp_parser* parser) -{ - tree mem_initializer_list = NULL_TREE; - - /* Let the semantic analysis code know that we are starting the - mem-initializer-list. */ - if (!DECL_CONSTRUCTOR_P (current_function_decl)) - error ("only constructors take base initializers"); - - /* Loop through the list. */ - while (true) - { - tree mem_initializer; - - /* Parse the mem-initializer. */ - mem_initializer = cp_parser_mem_initializer (parser); - /* Add it to the list, unless it was erroneous. */ - if (mem_initializer != error_mark_node) - { - TREE_CHAIN (mem_initializer) = mem_initializer_list; - mem_initializer_list = mem_initializer; - } - /* If the next token is not a `,', we're done. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) - break; - /* Consume the `,' token. */ - cp_lexer_consume_token (parser->lexer); - } - - /* Perform semantic analysis. */ - if (DECL_CONSTRUCTOR_P (current_function_decl)) - finish_mem_initializers (mem_initializer_list); -} - -/* Parse a mem-initializer. - - mem-initializer: - mem-initializer-id ( expression-list [opt] ) - - GNU extension: - - mem-initializer: - ( expression-list [opt] ) - - Returns a TREE_LIST. The TREE_PURPOSE is the TYPE (for a base - class) or FIELD_DECL (for a non-static data member) to initialize; - the TREE_VALUE is the expression-list. An empty initialization - list is represented by void_list_node. */ - -static tree -cp_parser_mem_initializer (cp_parser* parser) -{ - tree mem_initializer_id; - tree expression_list; - tree member; - - /* Find out what is being initialized. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - { - pedwarn ("anachronistic old-style base class initializer"); - mem_initializer_id = NULL_TREE; - } - else - mem_initializer_id = cp_parser_mem_initializer_id (parser); - member = expand_member_init (mem_initializer_id); - if (member && !DECL_P (member)) - in_base_initializer = 1; - - expression_list - = cp_parser_parenthesized_expression_list (parser, false, - /*cast_p=*/false, - /*non_constant_p=*/NULL); - if (expression_list == error_mark_node) - return error_mark_node; - if (!expression_list) - expression_list = void_type_node; - - in_base_initializer = 0; - - return member ? build_tree_list (member, expression_list) : error_mark_node; -} - -/* Parse a mem-initializer-id. - - mem-initializer-id: - :: [opt] nested-name-specifier [opt] class-name - identifier - - Returns a TYPE indicating the class to be initializer for the first - production. Returns an IDENTIFIER_NODE indicating the data member - to be initialized for the second production. */ - -static tree -cp_parser_mem_initializer_id (cp_parser* parser) -{ - bool global_scope_p; - bool nested_name_specifier_p; - bool template_p = false; - tree id; - - /* `typename' is not allowed in this context ([temp.res]). */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME)) - { - error ("keyword %<typename%> not allowed in this context (a qualified " - "member initializer is implicitly a type)"); - cp_lexer_consume_token (parser->lexer); - } - /* Look for the optional `::' operator. */ - global_scope_p - = (cp_parser_global_scope_opt (parser, - /*current_scope_valid_p=*/false) - != NULL_TREE); - /* Look for the optional nested-name-specifier. The simplest way to - implement: - - [temp.res] - - The keyword `typename' is not permitted in a base-specifier or - mem-initializer; in these contexts a qualified name that - depends on a template-parameter is implicitly assumed to be a - type name. - - is to assume that we have seen the `typename' keyword at this - point. */ - nested_name_specifier_p - = (cp_parser_nested_name_specifier_opt (parser, - /*typename_keyword_p=*/true, - /*check_dependency_p=*/true, - /*type_p=*/true, - /*is_declaration=*/true) - != NULL_TREE); - if (nested_name_specifier_p) - template_p = cp_parser_optional_template_keyword (parser); - /* If there is a `::' operator or a nested-name-specifier, then we - are definitely looking for a class-name. */ - if (global_scope_p || nested_name_specifier_p) - return cp_parser_class_name (parser, - /*typename_keyword_p=*/true, - /*template_keyword_p=*/template_p, - none_type, - /*check_dependency_p=*/true, - /*class_head_p=*/false, - /*is_declaration=*/true); - /* Otherwise, we could also be looking for an ordinary identifier. */ - cp_parser_parse_tentatively (parser); - /* Try a class-name. */ - id = cp_parser_class_name (parser, - /*typename_keyword_p=*/true, - /*template_keyword_p=*/false, - none_type, - /*check_dependency_p=*/true, - /*class_head_p=*/false, - /*is_declaration=*/true); - /* If we found one, we're done. */ - if (cp_parser_parse_definitely (parser)) - return id; - /* Otherwise, look for an ordinary identifier. */ - return cp_parser_identifier (parser); -} - -/* Overloading [gram.over] */ - -/* Parse an operator-function-id. - - operator-function-id: - operator operator - - Returns an IDENTIFIER_NODE for the operator which is a - human-readable spelling of the identifier, e.g., `operator +'. */ - -static tree -cp_parser_operator_function_id (cp_parser* parser) -{ - /* Look for the `operator' keyword. */ - if (!cp_parser_require_keyword (parser, RID_OPERATOR, "`operator'")) - return error_mark_node; - /* And then the name of the operator itself. */ - return cp_parser_operator (parser); -} - -/* Parse an operator. - - operator: - new delete new[] delete[] + - * / % ^ & | ~ ! = < > - += -= *= /= %= ^= &= |= << >> >>= <<= == != <= >= && - || ++ -- , ->* -> () [] - - GNU Extensions: - - operator: - <? >? <?= >?= - - Returns an IDENTIFIER_NODE for the operator which is a - human-readable spelling of the identifier, e.g., `operator +'. */ - -static tree -cp_parser_operator (cp_parser* parser) -{ - tree id = NULL_TREE; - cp_token *token; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Figure out which operator we have. */ - switch (token->type) - { - case CPP_KEYWORD: - { - enum tree_code op; - - /* The keyword should be either `new' or `delete'. */ - if (token->keyword == RID_NEW) - op = NEW_EXPR; - else if (token->keyword == RID_DELETE) - op = DELETE_EXPR; - else - break; - - /* Consume the `new' or `delete' token. */ - cp_lexer_consume_token (parser->lexer); - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's a `[' token then this is the array variant of the - operator. */ - if (token->type == CPP_OPEN_SQUARE) - { - /* Consume the `[' token. */ - cp_lexer_consume_token (parser->lexer); - /* Look for the `]' token. */ - cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"); - id = ansi_opname (op == NEW_EXPR - ? VEC_NEW_EXPR : VEC_DELETE_EXPR); - } - /* Otherwise, we have the non-array variant. */ - else - id = ansi_opname (op); - - return id; - } - - case CPP_PLUS: - id = ansi_opname (PLUS_EXPR); - break; - - case CPP_MINUS: - id = ansi_opname (MINUS_EXPR); - break; - - case CPP_MULT: - id = ansi_opname (MULT_EXPR); - break; - - case CPP_DIV: - id = ansi_opname (TRUNC_DIV_EXPR); - break; - - case CPP_MOD: - id = ansi_opname (TRUNC_MOD_EXPR); - break; - - case CPP_XOR: - id = ansi_opname (BIT_XOR_EXPR); - break; - - case CPP_AND: - id = ansi_opname (BIT_AND_EXPR); - break; - - case CPP_OR: - id = ansi_opname (BIT_IOR_EXPR); - break; - - case CPP_COMPL: - id = ansi_opname (BIT_NOT_EXPR); - break; - - case CPP_NOT: - id = ansi_opname (TRUTH_NOT_EXPR); - break; - - case CPP_EQ: - id = ansi_assopname (NOP_EXPR); - break; - - case CPP_LESS: - id = ansi_opname (LT_EXPR); - break; - - case CPP_GREATER: - id = ansi_opname (GT_EXPR); - break; - - case CPP_PLUS_EQ: - id = ansi_assopname (PLUS_EXPR); - break; - - case CPP_MINUS_EQ: - id = ansi_assopname (MINUS_EXPR); - break; - - case CPP_MULT_EQ: - id = ansi_assopname (MULT_EXPR); - break; - - case CPP_DIV_EQ: - id = ansi_assopname (TRUNC_DIV_EXPR); - break; - - case CPP_MOD_EQ: - id = ansi_assopname (TRUNC_MOD_EXPR); - break; - - case CPP_XOR_EQ: - id = ansi_assopname (BIT_XOR_EXPR); - break; - - case CPP_AND_EQ: - id = ansi_assopname (BIT_AND_EXPR); - break; - - case CPP_OR_EQ: - id = ansi_assopname (BIT_IOR_EXPR); - break; - - case CPP_LSHIFT: - id = ansi_opname (LSHIFT_EXPR); - break; - - case CPP_RSHIFT: - id = ansi_opname (RSHIFT_EXPR); - break; - - case CPP_LSHIFT_EQ: - id = ansi_assopname (LSHIFT_EXPR); - break; - - case CPP_RSHIFT_EQ: - id = ansi_assopname (RSHIFT_EXPR); - break; - - case CPP_EQ_EQ: - id = ansi_opname (EQ_EXPR); - break; - - case CPP_NOT_EQ: - id = ansi_opname (NE_EXPR); - break; - - case CPP_LESS_EQ: - id = ansi_opname (LE_EXPR); - break; - - case CPP_GREATER_EQ: - id = ansi_opname (GE_EXPR); - break; - - case CPP_AND_AND: - id = ansi_opname (TRUTH_ANDIF_EXPR); - break; - - case CPP_OR_OR: - id = ansi_opname (TRUTH_ORIF_EXPR); - break; - - case CPP_PLUS_PLUS: - id = ansi_opname (POSTINCREMENT_EXPR); - break; - - case CPP_MINUS_MINUS: - id = ansi_opname (PREDECREMENT_EXPR); - break; - - case CPP_COMMA: - id = ansi_opname (COMPOUND_EXPR); - break; - - case CPP_DEREF_STAR: - id = ansi_opname (MEMBER_REF); - break; - - case CPP_DEREF: - id = ansi_opname (COMPONENT_REF); - break; - - case CPP_OPEN_PAREN: - /* Consume the `('. */ - cp_lexer_consume_token (parser->lexer); - /* Look for the matching `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - return ansi_opname (CALL_EXPR); - - case CPP_OPEN_SQUARE: - /* Consume the `['. */ - cp_lexer_consume_token (parser->lexer); - /* Look for the matching `]'. */ - cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"); - return ansi_opname (ARRAY_REF); - - default: - /* Anything else is an error. */ - break; - } - - /* If we have selected an identifier, we need to consume the - operator token. */ - if (id) - cp_lexer_consume_token (parser->lexer); - /* Otherwise, no valid operator name was present. */ - else - { - cp_parser_error (parser, "expected operator"); - id = error_mark_node; - } - - return id; -} - -/* Parse a template-declaration. - - template-declaration: - export [opt] template < template-parameter-list > declaration - - If MEMBER_P is TRUE, this template-declaration occurs within a - class-specifier. - - The grammar rule given by the standard isn't correct. What - is really meant is: - - template-declaration: - export [opt] template-parameter-list-seq - decl-specifier-seq [opt] init-declarator [opt] ; - export [opt] template-parameter-list-seq - function-definition - - template-parameter-list-seq: - template-parameter-list-seq [opt] - template < template-parameter-list > */ - -static void -cp_parser_template_declaration (cp_parser* parser, bool member_p) -{ - /* Check for `export'. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXPORT)) - { - /* Consume the `export' token. */ - cp_lexer_consume_token (parser->lexer); - /* Warn that we do not support `export'. */ - warning (0, "keyword %<export%> not implemented, and will be ignored"); - } - - cp_parser_template_declaration_after_export (parser, member_p); -} - -/* Parse a template-parameter-list. - - template-parameter-list: - template-parameter - template-parameter-list , template-parameter - - Returns a TREE_LIST. Each node represents a template parameter. - The nodes are connected via their TREE_CHAINs. */ - -static tree -cp_parser_template_parameter_list (cp_parser* parser) -{ - tree parameter_list = NULL_TREE; - - begin_template_parm_list (); - while (true) - { - tree parameter; - cp_token *token; - bool is_non_type; - - /* Parse the template-parameter. */ - parameter = cp_parser_template_parameter (parser, &is_non_type); - /* Add it to the list. */ - if (parameter != error_mark_node) - parameter_list = process_template_parm (parameter_list, - parameter, - is_non_type); - else - { - tree err_parm = build_tree_list (parameter, parameter); - TREE_VALUE (err_parm) = error_mark_node; - parameter_list = chainon (parameter_list, err_parm); - } - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's not a `,', we're done. */ - if (token->type != CPP_COMMA) - break; - /* Otherwise, consume the `,' token. */ - cp_lexer_consume_token (parser->lexer); - } - - return end_template_parm_list (parameter_list); -} - -/* Parse a template-parameter. - - template-parameter: - type-parameter - parameter-declaration - - If all goes well, returns a TREE_LIST. The TREE_VALUE represents - the parameter. The TREE_PURPOSE is the default value, if any. - Returns ERROR_MARK_NODE on failure. *IS_NON_TYPE is set to true - iff this parameter is a non-type parameter. */ - -static tree -cp_parser_template_parameter (cp_parser* parser, bool *is_non_type) -{ - cp_token *token; - cp_parameter_declarator *parameter_declarator; - tree parm; - - /* Assume it is a type parameter or a template parameter. */ - *is_non_type = false; - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it is `class' or `template', we have a type-parameter. */ - if (token->keyword == RID_TEMPLATE) - return cp_parser_type_parameter (parser); - /* If it is `class' or `typename' we do not know yet whether it is a - type parameter or a non-type parameter. Consider: - - template <typename T, typename T::X X> ... - - or: - - template <class C, class D*> ... - - Here, the first parameter is a type parameter, and the second is - a non-type parameter. We can tell by looking at the token after - the identifier -- if it is a `,', `=', or `>' then we have a type - parameter. */ - if (token->keyword == RID_TYPENAME || token->keyword == RID_CLASS) - { - /* Peek at the token after `class' or `typename'. */ - token = cp_lexer_peek_nth_token (parser->lexer, 2); - /* If it's an identifier, skip it. */ - if (token->type == CPP_NAME) - token = cp_lexer_peek_nth_token (parser->lexer, 3); - /* Now, see if the token looks like the end of a template - parameter. */ - if (token->type == CPP_COMMA - || token->type == CPP_EQ - || token->type == CPP_GREATER) - return cp_parser_type_parameter (parser); - } - - /* Otherwise, it is a non-type parameter. - - [temp.param] - - When parsing a default template-argument for a non-type - template-parameter, the first non-nested `>' is taken as the end - of the template parameter-list rather than a greater-than - operator. */ - *is_non_type = true; - parameter_declarator - = cp_parser_parameter_declaration (parser, /*template_parm_p=*/true, - /*parenthesized_p=*/NULL); - parm = grokdeclarator (parameter_declarator->declarator, - ¶meter_declarator->decl_specifiers, - PARM, /*initialized=*/0, - /*attrlist=*/NULL); - if (parm == error_mark_node) - return error_mark_node; - return build_tree_list (parameter_declarator->default_argument, parm); -} - -/* Parse a type-parameter. - - type-parameter: - class identifier [opt] - class identifier [opt] = type-id - typename identifier [opt] - typename identifier [opt] = type-id - template < template-parameter-list > class identifier [opt] - template < template-parameter-list > class identifier [opt] - = id-expression - - Returns a TREE_LIST. The TREE_VALUE is itself a TREE_LIST. The - TREE_PURPOSE is the default-argument, if any. The TREE_VALUE is - the declaration of the parameter. */ - -static tree -cp_parser_type_parameter (cp_parser* parser) -{ - cp_token *token; - tree parameter; - - /* Look for a keyword to tell us what kind of parameter this is. */ - token = cp_parser_require (parser, CPP_KEYWORD, - "`class', `typename', or `template'"); - if (!token) - return error_mark_node; - - switch (token->keyword) - { - case RID_CLASS: - case RID_TYPENAME: - { - tree identifier; - tree default_argument; - - /* If the next token is an identifier, then it names the - parameter. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - identifier = cp_parser_identifier (parser); - else - identifier = NULL_TREE; - - /* Create the parameter. */ - parameter = finish_template_type_parm (class_type_node, identifier); - - /* If the next token is an `=', we have a default argument. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)) - { - /* Consume the `=' token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the default-argument. */ - push_deferring_access_checks (dk_no_deferred); - default_argument = cp_parser_type_id (parser); - pop_deferring_access_checks (); - } - else - default_argument = NULL_TREE; - - /* Create the combined representation of the parameter and the - default argument. */ - parameter = build_tree_list (default_argument, parameter); - } - break; - - case RID_TEMPLATE: - { - tree parameter_list; - tree identifier; - tree default_argument; - - /* Look for the `<'. */ - cp_parser_require (parser, CPP_LESS, "`<'"); - /* Parse the template-parameter-list. */ - parameter_list = cp_parser_template_parameter_list (parser); - /* Look for the `>'. */ - cp_parser_require (parser, CPP_GREATER, "`>'"); - /* Look for the `class' keyword. */ - cp_parser_require_keyword (parser, RID_CLASS, "`class'"); - /* If the next token is an `=', then there is a - default-argument. If the next token is a `>', we are at - the end of the parameter-list. If the next token is a `,', - then we are at the end of this parameter. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_EQ) - && cp_lexer_next_token_is_not (parser->lexer, CPP_GREATER) - && cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) - { - identifier = cp_parser_identifier (parser); - /* Treat invalid names as if the parameter were nameless. */ - if (identifier == error_mark_node) - identifier = NULL_TREE; - } - else - identifier = NULL_TREE; - - /* Create the template parameter. */ - parameter = finish_template_template_parm (class_type_node, - identifier); - - /* If the next token is an `=', then there is a - default-argument. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)) - { - bool is_template; - - /* Consume the `='. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the id-expression. */ - push_deferring_access_checks (dk_no_deferred); - default_argument - = cp_parser_id_expression (parser, - /*template_keyword_p=*/false, - /*check_dependency_p=*/true, - /*template_p=*/&is_template, - /*declarator_p=*/false, - /*optional_p=*/false); - if (TREE_CODE (default_argument) == TYPE_DECL) - /* If the id-expression was a template-id that refers to - a template-class, we already have the declaration here, - so no further lookup is needed. */ - ; - else - /* Look up the name. */ - default_argument - = cp_parser_lookup_name (parser, default_argument, - none_type, - /*is_template=*/is_template, - /*is_namespace=*/false, - /*check_dependency=*/true, - /*ambiguous_decls=*/NULL); - /* See if the default argument is valid. */ - default_argument - = check_template_template_default_arg (default_argument); - pop_deferring_access_checks (); - } - else - default_argument = NULL_TREE; - - /* Create the combined representation of the parameter and the - default argument. */ - parameter = build_tree_list (default_argument, parameter); - } - break; - - default: - gcc_unreachable (); - break; - } - - return parameter; -} - -/* Parse a template-id. - - template-id: - template-name < template-argument-list [opt] > - - If TEMPLATE_KEYWORD_P is TRUE, then we have just seen the - `template' keyword. In this case, a TEMPLATE_ID_EXPR will be - returned. Otherwise, if the template-name names a function, or set - of functions, returns a TEMPLATE_ID_EXPR. If the template-name - names a class, returns a TYPE_DECL for the specialization. - - If CHECK_DEPENDENCY_P is FALSE, names are looked up in - uninstantiated templates. */ - -static tree -cp_parser_template_id (cp_parser *parser, - bool template_keyword_p, - bool check_dependency_p, - bool is_declaration) -{ - int i; - tree template; - tree arguments; - tree template_id; - cp_token_position start_of_id = 0; - deferred_access_check *chk; - VEC (deferred_access_check,gc) *access_check; - cp_token *next_token, *next_token_2; - bool is_identifier; - - /* If the next token corresponds to a template-id, there is no need - to reparse it. */ - next_token = cp_lexer_peek_token (parser->lexer); - if (next_token->type == CPP_TEMPLATE_ID) - { - struct tree_check *check_value; - - /* Get the stored value. */ - check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value; - /* Perform any access checks that were deferred. */ - access_check = check_value->checks; - if (access_check) - { - for (i = 0 ; - VEC_iterate (deferred_access_check, access_check, i, chk) ; - ++i) - { - perform_or_defer_access_check (chk->binfo, - chk->decl, - chk->diag_decl); - } - } - /* Return the stored value. */ - return check_value->value; - } - - /* Avoid performing name lookup if there is no possibility of - finding a template-id. */ - if ((next_token->type != CPP_NAME && next_token->keyword != RID_OPERATOR) - || (next_token->type == CPP_NAME - && !cp_parser_nth_token_starts_template_argument_list_p - (parser, 2))) - { - cp_parser_error (parser, "expected template-id"); - return error_mark_node; - } - - /* Remember where the template-id starts. */ - if (cp_parser_uncommitted_to_tentative_parse_p (parser)) - start_of_id = cp_lexer_token_position (parser->lexer, false); - - push_deferring_access_checks (dk_deferred); - - /* Parse the template-name. */ - is_identifier = false; - template = cp_parser_template_name (parser, template_keyword_p, - check_dependency_p, - is_declaration, - &is_identifier); - if (template == error_mark_node || is_identifier) - { - pop_deferring_access_checks (); - return template; - } - - /* If we find the sequence `[:' after a template-name, it's probably - a digraph-typo for `< ::'. Substitute the tokens and check if we can - parse correctly the argument list. */ - next_token = cp_lexer_peek_token (parser->lexer); - next_token_2 = cp_lexer_peek_nth_token (parser->lexer, 2); - if (next_token->type == CPP_OPEN_SQUARE - && next_token->flags & DIGRAPH - && next_token_2->type == CPP_COLON - && !(next_token_2->flags & PREV_WHITE)) - { - cp_parser_parse_tentatively (parser); - /* Change `:' into `::'. */ - next_token_2->type = CPP_SCOPE; - /* Consume the first token (CPP_OPEN_SQUARE - which we pretend it is - CPP_LESS. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the arguments. */ - arguments = cp_parser_enclosed_template_argument_list (parser); - if (!cp_parser_parse_definitely (parser)) - { - /* If we couldn't parse an argument list, then we revert our changes - and return simply an error. Maybe this is not a template-id - after all. */ - next_token_2->type = CPP_COLON; - cp_parser_error (parser, "expected %<<%>"); - pop_deferring_access_checks (); - return error_mark_node; - } - /* Otherwise, emit an error about the invalid digraph, but continue - parsing because we got our argument list. */ - pedwarn ("%<<::%> cannot begin a template-argument list"); - inform ("%<<:%> is an alternate spelling for %<[%>. Insert whitespace " - "between %<<%> and %<::%>"); - if (!flag_permissive) - { - static bool hint; - if (!hint) - { - inform ("(if you use -fpermissive G++ will accept your code)"); - hint = true; - } - } - } - else - { - /* Look for the `<' that starts the template-argument-list. */ - if (!cp_parser_require (parser, CPP_LESS, "`<'")) - { - pop_deferring_access_checks (); - return error_mark_node; - } - /* Parse the arguments. */ - arguments = cp_parser_enclosed_template_argument_list (parser); - } - - /* Build a representation of the specialization. */ - if (TREE_CODE (template) == IDENTIFIER_NODE) - template_id = build_min_nt (TEMPLATE_ID_EXPR, template, arguments); - else if (DECL_CLASS_TEMPLATE_P (template) - || DECL_TEMPLATE_TEMPLATE_PARM_P (template)) - { - bool entering_scope; - /* In "template <typename T> ... A<T>::", A<T> is the abstract A - template (rather than some instantiation thereof) only if - is not nested within some other construct. For example, in - "template <typename T> void f(T) { A<T>::", A<T> is just an - instantiation of A. */ - entering_scope = (template_parm_scope_p () - && cp_lexer_next_token_is (parser->lexer, - CPP_SCOPE)); - template_id - = finish_template_type (template, arguments, entering_scope); - } - else - { - /* If it's not a class-template or a template-template, it should be - a function-template. */ - gcc_assert ((DECL_FUNCTION_TEMPLATE_P (template) - || TREE_CODE (template) == OVERLOAD - || BASELINK_P (template))); - - template_id = lookup_template_function (template, arguments); - } - - /* If parsing tentatively, replace the sequence of tokens that makes - up the template-id with a CPP_TEMPLATE_ID token. That way, - should we re-parse the token stream, we will not have to repeat - the effort required to do the parse, nor will we issue duplicate - error messages about problems during instantiation of the - template. */ - if (start_of_id) - { - cp_token *token = cp_lexer_token_at (parser->lexer, start_of_id); - - /* Reset the contents of the START_OF_ID token. */ - token->type = CPP_TEMPLATE_ID; - /* Retrieve any deferred checks. Do not pop this access checks yet - so the memory will not be reclaimed during token replacing below. */ - token->u.tree_check_value = GGC_CNEW (struct tree_check); - token->u.tree_check_value->value = template_id; - token->u.tree_check_value->checks = get_deferred_access_checks (); - token->keyword = RID_MAX; - - /* Purge all subsequent tokens. */ - cp_lexer_purge_tokens_after (parser->lexer, start_of_id); - - /* ??? Can we actually assume that, if template_id == - error_mark_node, we will have issued a diagnostic to the - user, as opposed to simply marking the tentative parse as - failed? */ - if (cp_parser_error_occurred (parser) && template_id != error_mark_node) - error ("parse error in template argument list"); - } - - pop_deferring_access_checks (); - return template_id; -} - -/* Parse a template-name. - - template-name: - identifier - - The standard should actually say: - - template-name: - identifier - operator-function-id - - A defect report has been filed about this issue. - - A conversion-function-id cannot be a template name because they cannot - be part of a template-id. In fact, looking at this code: - - a.operator K<int>() - - the conversion-function-id is "operator K<int>", and K<int> is a type-id. - It is impossible to call a templated conversion-function-id with an - explicit argument list, since the only allowed template parameter is - the type to which it is converting. - - If TEMPLATE_KEYWORD_P is true, then we have just seen the - `template' keyword, in a construction like: - - T::template f<3>() - - In that case `f' is taken to be a template-name, even though there - is no way of knowing for sure. - - Returns the TEMPLATE_DECL for the template, or an OVERLOAD if the - name refers to a set of overloaded functions, at least one of which - is a template, or an IDENTIFIER_NODE with the name of the template, - if TEMPLATE_KEYWORD_P is true. If CHECK_DEPENDENCY_P is FALSE, - names are looked up inside uninstantiated templates. */ - -static tree -cp_parser_template_name (cp_parser* parser, - bool template_keyword_p, - bool check_dependency_p, - bool is_declaration, - bool *is_identifier) -{ - tree identifier; - tree decl; - tree fns; - - /* If the next token is `operator', then we have either an - operator-function-id or a conversion-function-id. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_OPERATOR)) - { - /* We don't know whether we're looking at an - operator-function-id or a conversion-function-id. */ - cp_parser_parse_tentatively (parser); - /* Try an operator-function-id. */ - identifier = cp_parser_operator_function_id (parser); - /* If that didn't work, try a conversion-function-id. */ - if (!cp_parser_parse_definitely (parser)) - { - cp_parser_error (parser, "expected template-name"); - return error_mark_node; - } - } - /* Look for the identifier. */ - else - identifier = cp_parser_identifier (parser); - - /* If we didn't find an identifier, we don't have a template-id. */ - if (identifier == error_mark_node) - return error_mark_node; - - /* If the name immediately followed the `template' keyword, then it - is a template-name. However, if the next token is not `<', then - we do not treat it as a template-name, since it is not being used - as part of a template-id. This enables us to handle constructs - like: - - template <typename T> struct S { S(); }; - template <typename T> S<T>::S(); - - correctly. We would treat `S' as a template -- if it were `S<T>' - -- but we do not if there is no `<'. */ - - if (processing_template_decl - && cp_parser_nth_token_starts_template_argument_list_p (parser, 1)) - { - /* In a declaration, in a dependent context, we pretend that the - "template" keyword was present in order to improve error - recovery. For example, given: - - template <typename T> void f(T::X<int>); - - we want to treat "X<int>" as a template-id. */ - if (is_declaration - && !template_keyword_p - && parser->scope && TYPE_P (parser->scope) - && check_dependency_p - && dependent_type_p (parser->scope) - /* Do not do this for dtors (or ctors), since they never - need the template keyword before their name. */ - && !constructor_name_p (identifier, parser->scope)) - { - cp_token_position start = 0; - - /* Explain what went wrong. */ - error ("non-template %qD used as template", identifier); - inform ("use %<%T::template %D%> to indicate that it is a template", - parser->scope, identifier); - /* If parsing tentatively, find the location of the "<" token. */ - if (cp_parser_simulate_error (parser)) - start = cp_lexer_token_position (parser->lexer, true); - /* Parse the template arguments so that we can issue error - messages about them. */ - cp_lexer_consume_token (parser->lexer); - cp_parser_enclosed_template_argument_list (parser); - /* Skip tokens until we find a good place from which to - continue parsing. */ - cp_parser_skip_to_closing_parenthesis (parser, - /*recovering=*/true, - /*or_comma=*/true, - /*consume_paren=*/false); - /* If parsing tentatively, permanently remove the - template argument list. That will prevent duplicate - error messages from being issued about the missing - "template" keyword. */ - if (start) - cp_lexer_purge_tokens_after (parser->lexer, start); - if (is_identifier) - *is_identifier = true; - return identifier; - } - - /* If the "template" keyword is present, then there is generally - no point in doing name-lookup, so we just return IDENTIFIER. - But, if the qualifying scope is non-dependent then we can - (and must) do name-lookup normally. */ - if (template_keyword_p - && (!parser->scope - || (TYPE_P (parser->scope) - && dependent_type_p (parser->scope)))) - return identifier; - } - - /* Look up the name. */ - decl = cp_parser_lookup_name (parser, identifier, - none_type, - /*is_template=*/false, - /*is_namespace=*/false, - check_dependency_p, - /*ambiguous_decls=*/NULL); - decl = maybe_get_template_decl_from_type_decl (decl); - - /* If DECL is a template, then the name was a template-name. */ - if (TREE_CODE (decl) == TEMPLATE_DECL) - ; - else - { - tree fn = NULL_TREE; - - /* The standard does not explicitly indicate whether a name that - names a set of overloaded declarations, some of which are - templates, is a template-name. However, such a name should - be a template-name; otherwise, there is no way to form a - template-id for the overloaded templates. */ - fns = BASELINK_P (decl) ? BASELINK_FUNCTIONS (decl) : decl; - if (TREE_CODE (fns) == OVERLOAD) - for (fn = fns; fn; fn = OVL_NEXT (fn)) - if (TREE_CODE (OVL_CURRENT (fn)) == TEMPLATE_DECL) - break; - - if (!fn) - { - /* The name does not name a template. */ - cp_parser_error (parser, "expected template-name"); - return error_mark_node; - } - } - - /* If DECL is dependent, and refers to a function, then just return - its name; we will look it up again during template instantiation. */ - if (DECL_FUNCTION_TEMPLATE_P (decl) || !DECL_P (decl)) - { - tree scope = CP_DECL_CONTEXT (get_first_fn (decl)); - if (TYPE_P (scope) && dependent_type_p (scope)) - return identifier; - } - - return decl; -} - -/* Parse a template-argument-list. - - template-argument-list: - template-argument - template-argument-list , template-argument - - Returns a TREE_VEC containing the arguments. */ - -static tree -cp_parser_template_argument_list (cp_parser* parser) -{ - tree fixed_args[10]; - unsigned n_args = 0; - unsigned alloced = 10; - tree *arg_ary = fixed_args; - tree vec; - bool saved_in_template_argument_list_p; - bool saved_ice_p; - bool saved_non_ice_p; - - saved_in_template_argument_list_p = parser->in_template_argument_list_p; - parser->in_template_argument_list_p = true; - /* Even if the template-id appears in an integral - constant-expression, the contents of the argument list do - not. */ - saved_ice_p = parser->integral_constant_expression_p; - parser->integral_constant_expression_p = false; - saved_non_ice_p = parser->non_integral_constant_expression_p; - parser->non_integral_constant_expression_p = false; - /* Parse the arguments. */ - do - { - tree argument; - - if (n_args) - /* Consume the comma. */ - cp_lexer_consume_token (parser->lexer); - - /* Parse the template-argument. */ - argument = cp_parser_template_argument (parser); - if (n_args == alloced) - { - alloced *= 2; - - if (arg_ary == fixed_args) - { - arg_ary = XNEWVEC (tree, alloced); - memcpy (arg_ary, fixed_args, sizeof (tree) * n_args); - } - else - arg_ary = XRESIZEVEC (tree, arg_ary, alloced); - } - arg_ary[n_args++] = argument; - } - while (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)); - - vec = make_tree_vec (n_args); - - while (n_args--) - TREE_VEC_ELT (vec, n_args) = arg_ary[n_args]; - - if (arg_ary != fixed_args) - free (arg_ary); - parser->non_integral_constant_expression_p = saved_non_ice_p; - parser->integral_constant_expression_p = saved_ice_p; - parser->in_template_argument_list_p = saved_in_template_argument_list_p; - return vec; -} - -/* Parse a template-argument. - - template-argument: - assignment-expression - type-id - id-expression - - The representation is that of an assignment-expression, type-id, or - id-expression -- except that the qualified id-expression is - evaluated, so that the value returned is either a DECL or an - OVERLOAD. - - Although the standard says "assignment-expression", it forbids - throw-expressions or assignments in the template argument. - Therefore, we use "conditional-expression" instead. */ - -static tree -cp_parser_template_argument (cp_parser* parser) -{ - tree argument; - bool template_p; - bool address_p; - bool maybe_type_id = false; - cp_token *token; - cp_id_kind idk; - - /* There's really no way to know what we're looking at, so we just - try each alternative in order. - - [temp.arg] - - In a template-argument, an ambiguity between a type-id and an - expression is resolved to a type-id, regardless of the form of - the corresponding template-parameter. - - Therefore, we try a type-id first. */ - cp_parser_parse_tentatively (parser); - argument = cp_parser_type_id (parser); - /* If there was no error parsing the type-id but the next token is a '>>', - we probably found a typo for '> >'. But there are type-id which are - also valid expressions. For instance: - - struct X { int operator >> (int); }; - template <int V> struct Foo {}; - Foo<X () >> 5> r; - - Here 'X()' is a valid type-id of a function type, but the user just - wanted to write the expression "X() >> 5". Thus, we remember that we - found a valid type-id, but we still try to parse the argument as an - expression to see what happens. */ - if (!cp_parser_error_occurred (parser) - && cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT)) - { - maybe_type_id = true; - cp_parser_abort_tentative_parse (parser); - } - else - { - /* If the next token isn't a `,' or a `>', then this argument wasn't - really finished. This means that the argument is not a valid - type-id. */ - if (!cp_parser_next_token_ends_template_argument_p (parser)) - cp_parser_error (parser, "expected template-argument"); - /* If that worked, we're done. */ - if (cp_parser_parse_definitely (parser)) - return argument; - } - /* We're still not sure what the argument will be. */ - cp_parser_parse_tentatively (parser); - /* Try a template. */ - argument = cp_parser_id_expression (parser, - /*template_keyword_p=*/false, - /*check_dependency_p=*/true, - &template_p, - /*declarator_p=*/false, - /*optional_p=*/false); - /* If the next token isn't a `,' or a `>', then this argument wasn't - really finished. */ - if (!cp_parser_next_token_ends_template_argument_p (parser)) - cp_parser_error (parser, "expected template-argument"); - if (!cp_parser_error_occurred (parser)) - { - /* Figure out what is being referred to. If the id-expression - was for a class template specialization, then we will have a - TYPE_DECL at this point. There is no need to do name lookup - at this point in that case. */ - if (TREE_CODE (argument) != TYPE_DECL) - argument = cp_parser_lookup_name (parser, argument, - none_type, - /*is_template=*/template_p, - /*is_namespace=*/false, - /*check_dependency=*/true, - /*ambiguous_decls=*/NULL); - if (TREE_CODE (argument) != TEMPLATE_DECL - && TREE_CODE (argument) != UNBOUND_CLASS_TEMPLATE) - cp_parser_error (parser, "expected template-name"); - } - if (cp_parser_parse_definitely (parser)) - return argument; - /* It must be a non-type argument. There permitted cases are given - in [temp.arg.nontype]: - - -- an integral constant-expression of integral or enumeration - type; or - - -- the name of a non-type template-parameter; or - - -- the name of an object or function with external linkage... - - -- the address of an object or function with external linkage... - - -- a pointer to member... */ - /* Look for a non-type template parameter. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - { - cp_parser_parse_tentatively (parser); - argument = cp_parser_primary_expression (parser, - /*adress_p=*/false, - /*cast_p=*/false, - /*template_arg_p=*/true, - &idk); - if (TREE_CODE (argument) != TEMPLATE_PARM_INDEX - || !cp_parser_next_token_ends_template_argument_p (parser)) - cp_parser_simulate_error (parser); - if (cp_parser_parse_definitely (parser)) - return argument; - } - - /* If the next token is "&", the argument must be the address of an - object or function with external linkage. */ - address_p = cp_lexer_next_token_is (parser->lexer, CPP_AND); - if (address_p) - cp_lexer_consume_token (parser->lexer); - /* See if we might have an id-expression. */ - token = cp_lexer_peek_token (parser->lexer); - if (token->type == CPP_NAME - || token->keyword == RID_OPERATOR - || token->type == CPP_SCOPE - || token->type == CPP_TEMPLATE_ID - || token->type == CPP_NESTED_NAME_SPECIFIER) - { - cp_parser_parse_tentatively (parser); - argument = cp_parser_primary_expression (parser, - address_p, - /*cast_p=*/false, - /*template_arg_p=*/true, - &idk); - if (cp_parser_error_occurred (parser) - || !cp_parser_next_token_ends_template_argument_p (parser)) - cp_parser_abort_tentative_parse (parser); - else - { - if (TREE_CODE (argument) == INDIRECT_REF) - { - gcc_assert (REFERENCE_REF_P (argument)); - argument = TREE_OPERAND (argument, 0); - } - - if (TREE_CODE (argument) == VAR_DECL) - { - /* A variable without external linkage might still be a - valid constant-expression, so no error is issued here - if the external-linkage check fails. */ - if (!address_p && !DECL_EXTERNAL_LINKAGE_P (argument)) - cp_parser_simulate_error (parser); - } - else if (is_overloaded_fn (argument)) - /* All overloaded functions are allowed; if the external - linkage test does not pass, an error will be issued - later. */ - ; - else if (address_p - && (TREE_CODE (argument) == OFFSET_REF - || TREE_CODE (argument) == SCOPE_REF)) - /* A pointer-to-member. */ - ; - else if (TREE_CODE (argument) == TEMPLATE_PARM_INDEX) - ; - else - cp_parser_simulate_error (parser); - - if (cp_parser_parse_definitely (parser)) - { - if (address_p) - argument = build_x_unary_op (ADDR_EXPR, argument); - return argument; - } - } - } - /* If the argument started with "&", there are no other valid - alternatives at this point. */ - if (address_p) - { - cp_parser_error (parser, "invalid non-type template argument"); - return error_mark_node; - } - - /* If the argument wasn't successfully parsed as a type-id followed - by '>>', the argument can only be a constant expression now. - Otherwise, we try parsing the constant-expression tentatively, - because the argument could really be a type-id. */ - if (maybe_type_id) - cp_parser_parse_tentatively (parser); - argument = cp_parser_constant_expression (parser, - /*allow_non_constant_p=*/false, - /*non_constant_p=*/NULL); - argument = fold_non_dependent_expr (argument); - if (!maybe_type_id) - return argument; - if (!cp_parser_next_token_ends_template_argument_p (parser)) - cp_parser_error (parser, "expected template-argument"); - if (cp_parser_parse_definitely (parser)) - return argument; - /* We did our best to parse the argument as a non type-id, but that - was the only alternative that matched (albeit with a '>' after - it). We can assume it's just a typo from the user, and a - diagnostic will then be issued. */ - return cp_parser_type_id (parser); -} - -/* Parse an explicit-instantiation. - - explicit-instantiation: - template declaration - - Although the standard says `declaration', what it really means is: - - explicit-instantiation: - template decl-specifier-seq [opt] declarator [opt] ; - - Things like `template int S<int>::i = 5, int S<double>::j;' are not - supposed to be allowed. A defect report has been filed about this - issue. - - GNU Extension: - - explicit-instantiation: - storage-class-specifier template - decl-specifier-seq [opt] declarator [opt] ; - function-specifier template - decl-specifier-seq [opt] declarator [opt] ; */ - -static void -cp_parser_explicit_instantiation (cp_parser* parser) -{ - int declares_class_or_enum; - cp_decl_specifier_seq decl_specifiers; - tree extension_specifier = NULL_TREE; - - /* Look for an (optional) storage-class-specifier or - function-specifier. */ - if (cp_parser_allow_gnu_extensions_p (parser)) - { - extension_specifier - = cp_parser_storage_class_specifier_opt (parser); - if (!extension_specifier) - extension_specifier - = cp_parser_function_specifier_opt (parser, - /*decl_specs=*/NULL); - } - - /* Look for the `template' keyword. */ - cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'"); - /* Let the front end know that we are processing an explicit - instantiation. */ - begin_explicit_instantiation (); - /* [temp.explicit] says that we are supposed to ignore access - control while processing explicit instantiation directives. */ - push_deferring_access_checks (dk_no_check); - /* Parse a decl-specifier-seq. */ - cp_parser_decl_specifier_seq (parser, - CP_PARSER_FLAGS_OPTIONAL, - &decl_specifiers, - &declares_class_or_enum); - /* If there was exactly one decl-specifier, and it declared a class, - and there's no declarator, then we have an explicit type - instantiation. */ - if (declares_class_or_enum && cp_parser_declares_only_class_p (parser)) - { - tree type; - - type = check_tag_decl (&decl_specifiers); - /* Turn access control back on for names used during - template instantiation. */ - pop_deferring_access_checks (); - if (type) - do_type_instantiation (type, extension_specifier, - /*complain=*/tf_error); - } - else - { - cp_declarator *declarator; - tree decl; - - /* Parse the declarator. */ - declarator - = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED, - /*ctor_dtor_or_conv_p=*/NULL, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - if (declares_class_or_enum & 2) - cp_parser_check_for_definition_in_return_type (declarator, - decl_specifiers.type); - if (declarator != cp_error_declarator) - { - decl = grokdeclarator (declarator, &decl_specifiers, - NORMAL, 0, &decl_specifiers.attributes); - /* Turn access control back on for names used during - template instantiation. */ - pop_deferring_access_checks (); - /* Do the explicit instantiation. */ - do_decl_instantiation (decl, extension_specifier); - } - else - { - pop_deferring_access_checks (); - /* Skip the body of the explicit instantiation. */ - cp_parser_skip_to_end_of_statement (parser); - } - } - /* We're done with the instantiation. */ - end_explicit_instantiation (); - - cp_parser_consume_semicolon_at_end_of_statement (parser); -} - -/* Parse an explicit-specialization. - - explicit-specialization: - template < > declaration - - Although the standard says `declaration', what it really means is: - - explicit-specialization: - template <> decl-specifier [opt] init-declarator [opt] ; - template <> function-definition - template <> explicit-specialization - template <> template-declaration */ - -static void -cp_parser_explicit_specialization (cp_parser* parser) -{ - bool need_lang_pop; - /* Look for the `template' keyword. */ - cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'"); - /* Look for the `<'. */ - cp_parser_require (parser, CPP_LESS, "`<'"); - /* Look for the `>'. */ - cp_parser_require (parser, CPP_GREATER, "`>'"); - /* We have processed another parameter list. */ - ++parser->num_template_parameter_lists; - /* [temp] - - A template ... explicit specialization ... shall not have C - linkage. */ - if (current_lang_name == lang_name_c) - { - error ("template specialization with C linkage"); - /* Give it C++ linkage to avoid confusing other parts of the - front end. */ - push_lang_context (lang_name_cplusplus); - need_lang_pop = true; - } - else - need_lang_pop = false; - /* Let the front end know that we are beginning a specialization. */ - if (!begin_specialization ()) - { - end_specialization (); - cp_parser_skip_to_end_of_block_or_statement (parser); - return; - } - - /* If the next keyword is `template', we need to figure out whether - or not we're looking a template-declaration. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE)) - { - if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS - && cp_lexer_peek_nth_token (parser->lexer, 3)->type != CPP_GREATER) - cp_parser_template_declaration_after_export (parser, - /*member_p=*/false); - else - cp_parser_explicit_specialization (parser); - } - else - /* Parse the dependent declaration. */ - cp_parser_single_declaration (parser, - /*checks=*/NULL, - /*member_p=*/false, - /*friend_p=*/NULL); - /* We're done with the specialization. */ - end_specialization (); - /* For the erroneous case of a template with C linkage, we pushed an - implicit C++ linkage scope; exit that scope now. */ - if (need_lang_pop) - pop_lang_context (); - /* We're done with this parameter list. */ - --parser->num_template_parameter_lists; -} - -/* Parse a type-specifier. - - type-specifier: - simple-type-specifier - class-specifier - enum-specifier - elaborated-type-specifier - cv-qualifier - - GNU Extension: - - type-specifier: - __complex__ - - Returns a representation of the type-specifier. For a - class-specifier, enum-specifier, or elaborated-type-specifier, a - TREE_TYPE is returned; otherwise, a TYPE_DECL is returned. - - The parser flags FLAGS is used to control type-specifier parsing. - - If IS_DECLARATION is TRUE, then this type-specifier is appearing - in a decl-specifier-seq. - - If DECLARES_CLASS_OR_ENUM is non-NULL, and the type-specifier is a - class-specifier, enum-specifier, or elaborated-type-specifier, then - *DECLARES_CLASS_OR_ENUM is set to a nonzero value. The value is 1 - if a type is declared; 2 if it is defined. Otherwise, it is set to - zero. - - If IS_CV_QUALIFIER is non-NULL, and the type-specifier is a - cv-qualifier, then IS_CV_QUALIFIER is set to TRUE. Otherwise, it - is set to FALSE. */ - -static tree -cp_parser_type_specifier (cp_parser* parser, - cp_parser_flags flags, - cp_decl_specifier_seq *decl_specs, - bool is_declaration, - int* declares_class_or_enum, - bool* is_cv_qualifier) -{ - tree type_spec = NULL_TREE; - cp_token *token; - enum rid keyword; - cp_decl_spec ds = ds_last; - - /* Assume this type-specifier does not declare a new type. */ - if (declares_class_or_enum) - *declares_class_or_enum = 0; - /* And that it does not specify a cv-qualifier. */ - if (is_cv_qualifier) - *is_cv_qualifier = false; - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - - /* If we're looking at a keyword, we can use that to guide the - production we choose. */ - keyword = token->keyword; - switch (keyword) - { - case RID_ENUM: - /* Look for the enum-specifier. */ - type_spec = cp_parser_enum_specifier (parser); - /* If that worked, we're done. */ - if (type_spec) - { - if (declares_class_or_enum) - *declares_class_or_enum = 2; - if (decl_specs) - cp_parser_set_decl_spec_type (decl_specs, - type_spec, - /*user_defined_p=*/true); - return type_spec; - } - else - goto elaborated_type_specifier; - - /* Any of these indicate either a class-specifier, or an - elaborated-type-specifier. */ - case RID_CLASS: - case RID_STRUCT: - case RID_UNION: - /* Parse tentatively so that we can back up if we don't find a - class-specifier. */ - cp_parser_parse_tentatively (parser); - /* Look for the class-specifier. */ - type_spec = cp_parser_class_specifier (parser); - /* If that worked, we're done. */ - if (cp_parser_parse_definitely (parser)) - { - if (declares_class_or_enum) - *declares_class_or_enum = 2; - if (decl_specs) - cp_parser_set_decl_spec_type (decl_specs, - type_spec, - /*user_defined_p=*/true); - return type_spec; - } - - /* Fall through. */ - elaborated_type_specifier: - /* We're declaring (not defining) a class or enum. */ - if (declares_class_or_enum) - *declares_class_or_enum = 1; - - /* Fall through. */ - case RID_TYPENAME: - /* Look for an elaborated-type-specifier. */ - type_spec - = (cp_parser_elaborated_type_specifier - (parser, - decl_specs && decl_specs->specs[(int) ds_friend], - is_declaration)); - if (decl_specs) - cp_parser_set_decl_spec_type (decl_specs, - type_spec, - /*user_defined_p=*/true); - return type_spec; - - case RID_CONST: - ds = ds_const; - if (is_cv_qualifier) - *is_cv_qualifier = true; - break; - - case RID_VOLATILE: - ds = ds_volatile; - if (is_cv_qualifier) - *is_cv_qualifier = true; - break; - - case RID_RESTRICT: - ds = ds_restrict; - if (is_cv_qualifier) - *is_cv_qualifier = true; - break; - - case RID_COMPLEX: - /* The `__complex__' keyword is a GNU extension. */ - ds = ds_complex; - break; - - default: - break; - } - - /* Handle simple keywords. */ - if (ds != ds_last) - { - if (decl_specs) - { - ++decl_specs->specs[(int)ds]; - decl_specs->any_specifiers_p = true; - } - return cp_lexer_consume_token (parser->lexer)->u.value; - } - - /* If we do not already have a type-specifier, assume we are looking - at a simple-type-specifier. */ - type_spec = cp_parser_simple_type_specifier (parser, - decl_specs, - flags); - - /* If we didn't find a type-specifier, and a type-specifier was not - optional in this context, issue an error message. */ - if (!type_spec && !(flags & CP_PARSER_FLAGS_OPTIONAL)) - { - cp_parser_error (parser, "expected type specifier"); - return error_mark_node; - } - - return type_spec; -} - -/* Parse a simple-type-specifier. - - simple-type-specifier: - :: [opt] nested-name-specifier [opt] type-name - :: [opt] nested-name-specifier template template-id - char - wchar_t - bool - short - int - long - signed - unsigned - float - double - void - - GNU Extension: - - simple-type-specifier: - __typeof__ unary-expression - __typeof__ ( type-id ) - - Returns the indicated TYPE_DECL. If DECL_SPECS is not NULL, it is - appropriately updated. */ - -static tree -cp_parser_simple_type_specifier (cp_parser* parser, - cp_decl_specifier_seq *decl_specs, - cp_parser_flags flags) -{ - tree type = NULL_TREE; - cp_token *token; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - - /* If we're looking at a keyword, things are easy. */ - switch (token->keyword) - { - case RID_CHAR: - if (decl_specs) - decl_specs->explicit_char_p = true; - type = char_type_node; - break; - case RID_WCHAR: - type = wchar_type_node; - break; - case RID_BOOL: - type = boolean_type_node; - break; - case RID_SHORT: - if (decl_specs) - ++decl_specs->specs[(int) ds_short]; - type = short_integer_type_node; - break; - case RID_INT: - if (decl_specs) - decl_specs->explicit_int_p = true; - type = integer_type_node; - break; - case RID_LONG: - if (decl_specs) - ++decl_specs->specs[(int) ds_long]; - type = long_integer_type_node; - break; - case RID_SIGNED: - if (decl_specs) - ++decl_specs->specs[(int) ds_signed]; - type = integer_type_node; - break; - case RID_UNSIGNED: - if (decl_specs) - ++decl_specs->specs[(int) ds_unsigned]; - type = unsigned_type_node; - break; - case RID_FLOAT: - type = float_type_node; - break; - case RID_DOUBLE: - type = double_type_node; - break; - case RID_VOID: - type = void_type_node; - break; - - case RID_TYPEOF: - /* Consume the `typeof' token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the operand to `typeof'. */ - type = cp_parser_sizeof_operand (parser, RID_TYPEOF); - /* If it is not already a TYPE, take its type. */ - if (!TYPE_P (type)) - type = finish_typeof (type); - - if (decl_specs) - cp_parser_set_decl_spec_type (decl_specs, type, - /*user_defined_p=*/true); - - return type; - - default: - break; - } - - /* If the type-specifier was for a built-in type, we're done. */ - if (type) - { - tree id; - - /* Record the type. */ - if (decl_specs - && (token->keyword != RID_SIGNED - && token->keyword != RID_UNSIGNED - && token->keyword != RID_SHORT - && token->keyword != RID_LONG)) - cp_parser_set_decl_spec_type (decl_specs, - type, - /*user_defined=*/false); - if (decl_specs) - decl_specs->any_specifiers_p = true; - - /* Consume the token. */ - id = cp_lexer_consume_token (parser->lexer)->u.value; - - /* There is no valid C++ program where a non-template type is - followed by a "<". That usually indicates that the user thought - that the type was a template. */ - cp_parser_check_for_invalid_template_id (parser, type); - - return TYPE_NAME (type); - } - - /* The type-specifier must be a user-defined type. */ - if (!(flags & CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES)) - { - bool qualified_p; - bool global_p; - - /* Don't gobble tokens or issue error messages if this is an - optional type-specifier. */ - if (flags & CP_PARSER_FLAGS_OPTIONAL) - cp_parser_parse_tentatively (parser); - - /* Look for the optional `::' operator. */ - global_p - = (cp_parser_global_scope_opt (parser, - /*current_scope_valid_p=*/false) - != NULL_TREE); - /* Look for the nested-name specifier. */ - qualified_p - = (cp_parser_nested_name_specifier_opt (parser, - /*typename_keyword_p=*/false, - /*check_dependency_p=*/true, - /*type_p=*/false, - /*is_declaration=*/false) - != NULL_TREE); - /* If we have seen a nested-name-specifier, and the next token - is `template', then we are using the template-id production. */ - if (parser->scope - && cp_parser_optional_template_keyword (parser)) - { - /* Look for the template-id. */ - type = cp_parser_template_id (parser, - /*template_keyword_p=*/true, - /*check_dependency_p=*/true, - /*is_declaration=*/false); - /* If the template-id did not name a type, we are out of - luck. */ - if (TREE_CODE (type) != TYPE_DECL) - { - cp_parser_error (parser, "expected template-id for type"); - type = NULL_TREE; - } - } - /* Otherwise, look for a type-name. */ - else - type = cp_parser_type_name (parser); - /* Keep track of all name-lookups performed in class scopes. */ - if (type - && !global_p - && !qualified_p - && TREE_CODE (type) == TYPE_DECL - && TREE_CODE (DECL_NAME (type)) == IDENTIFIER_NODE) - maybe_note_name_used_in_class (DECL_NAME (type), type); - /* If it didn't work out, we don't have a TYPE. */ - if ((flags & CP_PARSER_FLAGS_OPTIONAL) - && !cp_parser_parse_definitely (parser)) - type = NULL_TREE; - if (type && decl_specs) - cp_parser_set_decl_spec_type (decl_specs, type, - /*user_defined=*/true); - } - - /* If we didn't get a type-name, issue an error message. */ - if (!type && !(flags & CP_PARSER_FLAGS_OPTIONAL)) - { - cp_parser_error (parser, "expected type-name"); - return error_mark_node; - } - - /* There is no valid C++ program where a non-template type is - followed by a "<". That usually indicates that the user thought - that the type was a template. */ - if (type && type != error_mark_node) - { - /* As a last-ditch effort, see if TYPE is an Objective-C type. - If it is, then the '<'...'>' enclose protocol names rather than - template arguments, and so everything is fine. */ - /* APPLE LOCAL radar 4516785 */ - if (c_dialect_objc () && !parser->scope - && (objc_is_id (type) || objc_is_class_name (type))) - { - tree protos = cp_parser_objc_protocol_refs_opt (parser); - tree qual_type = objc_get_protocol_qualified_type (type, protos); - - /* Clobber the "unqualified" type previously entered into - DECL_SPECS with the new, improved protocol-qualified version. */ - if (decl_specs) - decl_specs->type = qual_type; - - return qual_type; - } - - cp_parser_check_for_invalid_template_id (parser, TREE_TYPE (type)); - } - - return type; -} - -/* Parse a type-name. - - type-name: - class-name - enum-name - typedef-name - - enum-name: - identifier - - typedef-name: - identifier - - Returns a TYPE_DECL for the type. */ - -static tree -cp_parser_type_name (cp_parser* parser) -{ - tree type_decl; - tree identifier; - - /* We can't know yet whether it is a class-name or not. */ - cp_parser_parse_tentatively (parser); - /* Try a class-name. */ - type_decl = cp_parser_class_name (parser, - /*typename_keyword_p=*/false, - /*template_keyword_p=*/false, - none_type, - /*check_dependency_p=*/true, - /*class_head_p=*/false, - /*is_declaration=*/false); - /* If it's not a class-name, keep looking. */ - if (!cp_parser_parse_definitely (parser)) - { - /* It must be a typedef-name or an enum-name. */ - identifier = cp_parser_identifier (parser); - if (identifier == error_mark_node) - return error_mark_node; - - /* Look up the type-name. */ - type_decl = cp_parser_lookup_name_simple (parser, identifier); - - if (TREE_CODE (type_decl) != TYPE_DECL - && (objc_is_id (identifier) || objc_is_class_name (identifier))) - { - /* See if this is an Objective-C type. */ - /* APPLE LOCAL begin radar 5355344 */ - tree protos; - if (cp_parser_objc_tentative_protocol_refs_opt (parser, &protos)) - { - tree type = objc_get_protocol_qualified_type (identifier, protos); - if (type) - type_decl = TYPE_NAME (type); - } - /* APPLE LOCAL end radar 5355344 */ - } - - /* Issue an error if we did not find a type-name. */ - /* APPLE LOCAL begin radar 5277239 */ - if (TREE_CODE (type_decl) != TYPE_DECL - || cp_objc_property_reference_prefix (parser, TREE_TYPE (type_decl))) - /* APPLE LOCAL end radar 5277239 */ - { - if (!cp_parser_simulate_error (parser)) - cp_parser_name_lookup_error (parser, identifier, type_decl, - "is not a type"); - type_decl = error_mark_node; - } - /* Remember that the name was used in the definition of the - current class so that we can check later to see if the - meaning would have been different after the class was - entirely defined. */ - else if (type_decl != error_mark_node - && !parser->scope) - maybe_note_name_used_in_class (identifier, type_decl); - } - - return type_decl; -} - - -/* Parse an elaborated-type-specifier. Note that the grammar given - here incorporates the resolution to DR68. - - elaborated-type-specifier: - class-key :: [opt] nested-name-specifier [opt] identifier - class-key :: [opt] nested-name-specifier [opt] template [opt] template-id - enum :: [opt] nested-name-specifier [opt] identifier - typename :: [opt] nested-name-specifier identifier - typename :: [opt] nested-name-specifier template [opt] - template-id - - GNU extension: - - elaborated-type-specifier: - class-key attributes :: [opt] nested-name-specifier [opt] identifier - class-key attributes :: [opt] nested-name-specifier [opt] - template [opt] template-id - enum attributes :: [opt] nested-name-specifier [opt] identifier - - If IS_FRIEND is TRUE, then this elaborated-type-specifier is being - declared `friend'. If IS_DECLARATION is TRUE, then this - elaborated-type-specifier appears in a decl-specifiers-seq, i.e., - something is being declared. - - Returns the TYPE specified. */ - -static tree -cp_parser_elaborated_type_specifier (cp_parser* parser, - bool is_friend, - bool is_declaration) -{ - enum tag_types tag_type; - tree identifier; - tree type = NULL_TREE; - tree attributes = NULL_TREE; - - /* See if we're looking at the `enum' keyword. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ENUM)) - { - /* Consume the `enum' token. */ - cp_lexer_consume_token (parser->lexer); - /* Remember that it's an enumeration type. */ - tag_type = enum_type; - /* Parse the attributes. */ - attributes = cp_parser_attributes_opt (parser); - } - /* Or, it might be `typename'. */ - else if (cp_lexer_next_token_is_keyword (parser->lexer, - RID_TYPENAME)) - { - /* Consume the `typename' token. */ - cp_lexer_consume_token (parser->lexer); - /* Remember that it's a `typename' type. */ - tag_type = typename_type; - /* The `typename' keyword is only allowed in templates. */ - if (!processing_template_decl) - pedwarn ("using %<typename%> outside of template"); - } - /* Otherwise it must be a class-key. */ - else - { - tag_type = cp_parser_class_key (parser); - if (tag_type == none_type) - return error_mark_node; - /* Parse the attributes. */ - attributes = cp_parser_attributes_opt (parser); - } - - /* Look for the `::' operator. */ - cp_parser_global_scope_opt (parser, - /*current_scope_valid_p=*/false); - /* Look for the nested-name-specifier. */ - if (tag_type == typename_type) - { - if (!cp_parser_nested_name_specifier (parser, - /*typename_keyword_p=*/true, - /*check_dependency_p=*/true, - /*type_p=*/true, - is_declaration)) - return error_mark_node; - } - else - /* Even though `typename' is not present, the proposed resolution - to Core Issue 180 says that in `class A<T>::B', `B' should be - considered a type-name, even if `A<T>' is dependent. */ - cp_parser_nested_name_specifier_opt (parser, - /*typename_keyword_p=*/true, - /*check_dependency_p=*/true, - /*type_p=*/true, - is_declaration); - /* For everything but enumeration types, consider a template-id. - For an enumeration type, consider only a plain identifier. */ - if (tag_type != enum_type) - { - bool template_p = false; - tree decl; - - /* Allow the `template' keyword. */ - template_p = cp_parser_optional_template_keyword (parser); - /* If we didn't see `template', we don't know if there's a - template-id or not. */ - if (!template_p) - cp_parser_parse_tentatively (parser); - /* Parse the template-id. */ - decl = cp_parser_template_id (parser, template_p, - /*check_dependency_p=*/true, - is_declaration); - /* If we didn't find a template-id, look for an ordinary - identifier. */ - if (!template_p && !cp_parser_parse_definitely (parser)) - ; - /* If DECL is a TEMPLATE_ID_EXPR, and the `typename' keyword is - in effect, then we must assume that, upon instantiation, the - template will correspond to a class. */ - else if (TREE_CODE (decl) == TEMPLATE_ID_EXPR - && tag_type == typename_type) - type = make_typename_type (parser->scope, decl, - typename_type, - /*complain=*/tf_error); - else - type = TREE_TYPE (decl); - } - - if (!type) - { - identifier = cp_parser_identifier (parser); - - if (identifier == error_mark_node) - { - parser->scope = NULL_TREE; - return error_mark_node; - } - - /* For a `typename', we needn't call xref_tag. */ - if (tag_type == typename_type - && TREE_CODE (parser->scope) != NAMESPACE_DECL) - return cp_parser_make_typename_type (parser, parser->scope, - identifier); - /* Look up a qualified name in the usual way. */ - if (parser->scope) - { - tree decl; - - decl = cp_parser_lookup_name (parser, identifier, - tag_type, - /*is_template=*/false, - /*is_namespace=*/false, - /*check_dependency=*/true, - /*ambiguous_decls=*/NULL); - - /* If we are parsing friend declaration, DECL may be a - TEMPLATE_DECL tree node here. However, we need to check - whether this TEMPLATE_DECL results in valid code. Consider - the following example: - - namespace N { - template <class T> class C {}; - } - class X { - template <class T> friend class N::C; // #1, valid code - }; - template <class T> class Y { - friend class N::C; // #2, invalid code - }; - - For both case #1 and #2, we arrive at a TEMPLATE_DECL after - name lookup of `N::C'. We see that friend declaration must - be template for the code to be valid. Note that - processing_template_decl does not work here since it is - always 1 for the above two cases. */ - - decl = (cp_parser_maybe_treat_template_as_class - (decl, /*tag_name_p=*/is_friend - && parser->num_template_parameter_lists)); - - if (TREE_CODE (decl) != TYPE_DECL) - { - cp_parser_diagnose_invalid_type_name (parser, - parser->scope, - identifier); - return error_mark_node; - } - - if (TREE_CODE (TREE_TYPE (decl)) != TYPENAME_TYPE) - { - bool allow_template = (parser->num_template_parameter_lists - || DECL_SELF_REFERENCE_P (decl)); - type = check_elaborated_type_specifier (tag_type, decl, - allow_template); - - if (type == error_mark_node) - return error_mark_node; - } - - type = TREE_TYPE (decl); - } - else - { - /* An elaborated-type-specifier sometimes introduces a new type and - sometimes names an existing type. Normally, the rule is that it - introduces a new type only if there is not an existing type of - the same name already in scope. For example, given: - - struct S {}; - void f() { struct S s; } - - the `struct S' in the body of `f' is the same `struct S' as in - the global scope; the existing definition is used. However, if - there were no global declaration, this would introduce a new - local class named `S'. - - An exception to this rule applies to the following code: - - namespace N { struct S; } - - Here, the elaborated-type-specifier names a new type - unconditionally; even if there is already an `S' in the - containing scope this declaration names a new type. - This exception only applies if the elaborated-type-specifier - forms the complete declaration: - - [class.name] - - A declaration consisting solely of `class-key identifier ;' is - either a redeclaration of the name in the current scope or a - forward declaration of the identifier as a class name. It - introduces the name into the current scope. - - We are in this situation precisely when the next token is a `;'. - - An exception to the exception is that a `friend' declaration does - *not* name a new type; i.e., given: - - struct S { friend struct T; }; - - `T' is not a new type in the scope of `S'. - - Also, `new struct S' or `sizeof (struct S)' never results in the - definition of a new type; a new type can only be declared in a - declaration context. */ - - tag_scope ts; - bool template_p; - - if (is_friend) - /* Friends have special name lookup rules. */ - ts = ts_within_enclosing_non_class; - else if (is_declaration - && cp_lexer_next_token_is (parser->lexer, - CPP_SEMICOLON)) - /* This is a `class-key identifier ;' */ - ts = ts_current; - else - ts = ts_global; - - template_p = - (parser->num_template_parameter_lists - && (cp_parser_next_token_starts_class_definition_p (parser) - || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON))); - /* An unqualified name was used to reference this type, so - there were no qualifying templates. */ - if (!cp_parser_check_template_parameters (parser, - /*num_templates=*/0)) - return error_mark_node; - type = xref_tag (tag_type, identifier, ts, template_p); - } - } - - if (type == error_mark_node) - return error_mark_node; - - /* Allow attributes on forward declarations of classes. */ - if (attributes) - { - if (TREE_CODE (type) == TYPENAME_TYPE) - warning (OPT_Wattributes, - "attributes ignored on uninstantiated type"); - else if (tag_type != enum_type && CLASSTYPE_TEMPLATE_INSTANTIATION (type) - && ! processing_explicit_instantiation) - warning (OPT_Wattributes, - "attributes ignored on template instantiation"); - else if (is_declaration && cp_parser_declares_only_class_p (parser)) - cplus_decl_attributes (&type, attributes, (int) ATTR_FLAG_TYPE_IN_PLACE); - else - warning (OPT_Wattributes, - "attributes ignored on elaborated-type-specifier that is not a forward declaration"); - } - - if (tag_type != enum_type) - cp_parser_check_class_key (tag_type, type); - - /* A "<" cannot follow an elaborated type specifier. If that - happens, the user was probably trying to form a template-id. */ - cp_parser_check_for_invalid_template_id (parser, type); - - return type; -} - -/* Parse an enum-specifier. - - enum-specifier: - enum identifier [opt] { enumerator-list [opt] } - - GNU Extensions: - enum attributes[opt] identifier [opt] { enumerator-list [opt] } - attributes[opt] - - Returns an ENUM_TYPE representing the enumeration, or NULL_TREE - if the token stream isn't an enum-specifier after all. */ - -static tree -cp_parser_enum_specifier (cp_parser* parser) -{ - tree identifier; - tree type; - tree attributes; - - /* Parse tentatively so that we can back up if we don't find a - enum-specifier. */ - cp_parser_parse_tentatively (parser); - - /* Caller guarantees that the current token is 'enum', an identifier - possibly follows, and the token after that is an opening brace. - If we don't have an identifier, fabricate an anonymous name for - the enumeration being defined. */ - cp_lexer_consume_token (parser->lexer); - - attributes = cp_parser_attributes_opt (parser); - - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - identifier = cp_parser_identifier (parser); - else - identifier = make_anon_name (); - - /* Look for the `{' but don't consume it yet. */ - if (!cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) - cp_parser_simulate_error (parser); - - if (!cp_parser_parse_definitely (parser)) - return NULL_TREE; - - /* Issue an error message if type-definitions are forbidden here. */ - if (!cp_parser_check_type_definition (parser)) - type = error_mark_node; - else - /* Create the new type. We do this before consuming the opening - brace so the enum will be recorded as being on the line of its - tag (or the 'enum' keyword, if there is no tag). */ - type = start_enum (identifier); - - /* Consume the opening brace. */ - cp_lexer_consume_token (parser->lexer); - - if (type == error_mark_node) - { - cp_parser_skip_to_end_of_block_or_statement (parser); - return error_mark_node; - } - - /* If the next token is not '}', then there are some enumerators. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE)) - cp_parser_enumerator_list (parser, type); - - /* Consume the final '}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - - /* Look for trailing attributes to apply to this enumeration, and - apply them if appropriate. */ - if (cp_parser_allow_gnu_extensions_p (parser)) - { - tree trailing_attr = cp_parser_attributes_opt (parser); - cplus_decl_attributes (&type, - trailing_attr, - (int) ATTR_FLAG_TYPE_IN_PLACE); - } - - /* Finish up the enumeration. */ - finish_enum (type); - - return type; -} - -/* Parse an enumerator-list. The enumerators all have the indicated - TYPE. - - enumerator-list: - enumerator-definition - enumerator-list , enumerator-definition */ - -static void -cp_parser_enumerator_list (cp_parser* parser, tree type) -{ - while (true) - { - /* Parse an enumerator-definition. */ - cp_parser_enumerator_definition (parser, type); - - /* If the next token is not a ',', we've reached the end of - the list. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) - break; - /* Otherwise, consume the `,' and keep going. */ - cp_lexer_consume_token (parser->lexer); - /* If the next token is a `}', there is a trailing comma. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE)) - { - if (pedantic && !in_system_header) - pedwarn ("comma at end of enumerator list"); - break; - } - } -} - -/* Parse an enumerator-definition. The enumerator has the indicated - TYPE. - - enumerator-definition: - enumerator - enumerator = constant-expression - - enumerator: - identifier */ - -static void -cp_parser_enumerator_definition (cp_parser* parser, tree type) -{ - tree identifier; - tree value; - - /* Look for the identifier. */ - identifier = cp_parser_identifier (parser); - if (identifier == error_mark_node) - return; - - /* If the next token is an '=', then there is an explicit value. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)) - { - /* Consume the `=' token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the value. */ - value = cp_parser_constant_expression (parser, - /*allow_non_constant_p=*/false, - NULL); - } - else - value = NULL_TREE; - - /* Create the enumerator. */ - build_enumerator (identifier, value, type); -} - -/* Parse a namespace-name. - - namespace-name: - original-namespace-name - namespace-alias - - Returns the NAMESPACE_DECL for the namespace. */ - -static tree -cp_parser_namespace_name (cp_parser* parser) -{ - tree identifier; - tree namespace_decl; - - /* Get the name of the namespace. */ - identifier = cp_parser_identifier (parser); - if (identifier == error_mark_node) - return error_mark_node; - - /* Look up the identifier in the currently active scope. Look only - for namespaces, due to: - - [basic.lookup.udir] - - When looking up a namespace-name in a using-directive or alias - definition, only namespace names are considered. - - And: - - [basic.lookup.qual] - - During the lookup of a name preceding the :: scope resolution - operator, object, function, and enumerator names are ignored. - - (Note that cp_parser_class_or_namespace_name only calls this - function if the token after the name is the scope resolution - operator.) */ - namespace_decl = cp_parser_lookup_name (parser, identifier, - none_type, - /*is_template=*/false, - /*is_namespace=*/true, - /*check_dependency=*/true, - /*ambiguous_decls=*/NULL); - /* If it's not a namespace, issue an error. */ - if (namespace_decl == error_mark_node - || TREE_CODE (namespace_decl) != NAMESPACE_DECL) - { - if (!cp_parser_uncommitted_to_tentative_parse_p (parser)) - error ("%qD is not a namespace-name", identifier); - cp_parser_error (parser, "expected namespace-name"); - namespace_decl = error_mark_node; - } - - return namespace_decl; -} - -/* Parse a namespace-definition. - - namespace-definition: - named-namespace-definition - unnamed-namespace-definition - - named-namespace-definition: - original-namespace-definition - extension-namespace-definition - - original-namespace-definition: - namespace identifier { namespace-body } - - extension-namespace-definition: - namespace original-namespace-name { namespace-body } - - unnamed-namespace-definition: - namespace { namespace-body } */ - -static void -cp_parser_namespace_definition (cp_parser* parser) -{ - tree identifier, attribs; - /* APPLE LOCAL visibility 5805832 */ - bool visibility_pushed = false; - - /* Look for the `namespace' keyword. */ - cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'"); - - /* Get the name of the namespace. We do not attempt to distinguish - between an original-namespace-definition and an - extension-namespace-definition at this point. The semantic - analysis routines are responsible for that. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - identifier = cp_parser_identifier (parser); - else - identifier = NULL_TREE; - - /* Parse any specified attributes. */ - attribs = cp_parser_attributes_opt (parser); - - /* Look for the `{' to start the namespace. */ - cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"); - /* Start the namespace. */ - /* APPLE LOCAL visibility 5805832 */ - visibility_pushed = push_namespace_with_attribs (identifier, attribs); - /* Parse the body of the namespace. */ - cp_parser_namespace_body (parser); - /* APPLE LOCAL begin visibility 5805832 */ -#ifdef HANDLE_PRAGMA_VISIBILITY - if (visibility_pushed) - pop_visibility (); -#endif - /* APPLE LOCAL end visibility 5805832 */ - /* Finish the namespace. */ - pop_namespace (); - /* Look for the final `}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); -} - -/* Parse a namespace-body. - - namespace-body: - declaration-seq [opt] */ - -static void -cp_parser_namespace_body (cp_parser* parser) -{ - cp_parser_declaration_seq_opt (parser); -} - -/* Parse a namespace-alias-definition. - - namespace-alias-definition: - namespace identifier = qualified-namespace-specifier ; */ - -static void -cp_parser_namespace_alias_definition (cp_parser* parser) -{ - tree identifier; - tree namespace_specifier; - - /* Look for the `namespace' keyword. */ - cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'"); - /* Look for the identifier. */ - identifier = cp_parser_identifier (parser); - if (identifier == error_mark_node) - return; - /* Look for the `=' token. */ - cp_parser_require (parser, CPP_EQ, "`='"); - /* Look for the qualified-namespace-specifier. */ - namespace_specifier - = cp_parser_qualified_namespace_specifier (parser); - /* Look for the `;' token. */ - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); - - /* Register the alias in the symbol table. */ - do_namespace_alias (identifier, namespace_specifier); -} - -/* Parse a qualified-namespace-specifier. - - qualified-namespace-specifier: - :: [opt] nested-name-specifier [opt] namespace-name - - Returns a NAMESPACE_DECL corresponding to the specified - namespace. */ - -static tree -cp_parser_qualified_namespace_specifier (cp_parser* parser) -{ - /* Look for the optional `::'. */ - cp_parser_global_scope_opt (parser, - /*current_scope_valid_p=*/false); - - /* Look for the optional nested-name-specifier. */ - cp_parser_nested_name_specifier_opt (parser, - /*typename_keyword_p=*/false, - /*check_dependency_p=*/true, - /*type_p=*/false, - /*is_declaration=*/true); - - return cp_parser_namespace_name (parser); -} - -/* Parse a using-declaration, or, if ACCESS_DECLARATION_P is true, an - access declaration. - - using-declaration: - using typename [opt] :: [opt] nested-name-specifier unqualified-id ; - using :: unqualified-id ; - - access-declaration: - qualified-id ; - - */ - -static bool -cp_parser_using_declaration (cp_parser* parser, - bool access_declaration_p) -{ - cp_token *token; - bool typename_p = false; - bool global_scope_p; - tree decl; - tree identifier; - tree qscope; - - if (access_declaration_p) - cp_parser_parse_tentatively (parser); - else - { - /* Look for the `using' keyword. */ - cp_parser_require_keyword (parser, RID_USING, "`using'"); - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* See if it's `typename'. */ - if (token->keyword == RID_TYPENAME) - { - /* Remember that we've seen it. */ - typename_p = true; - /* Consume the `typename' token. */ - cp_lexer_consume_token (parser->lexer); - } - } - - /* Look for the optional global scope qualification. */ - global_scope_p - = (cp_parser_global_scope_opt (parser, - /*current_scope_valid_p=*/false) - != NULL_TREE); - - /* If we saw `typename', or didn't see `::', then there must be a - nested-name-specifier present. */ - if (typename_p || !global_scope_p) - qscope = cp_parser_nested_name_specifier (parser, typename_p, - /*check_dependency_p=*/true, - /*type_p=*/false, - /*is_declaration=*/true); - /* Otherwise, we could be in either of the two productions. In that - case, treat the nested-name-specifier as optional. */ - else - qscope = cp_parser_nested_name_specifier_opt (parser, - /*typename_keyword_p=*/false, - /*check_dependency_p=*/true, - /*type_p=*/false, - /*is_declaration=*/true); - if (!qscope) - qscope = global_namespace; - - if (access_declaration_p && cp_parser_error_occurred (parser)) - /* Something has already gone wrong; there's no need to parse - further. Since an error has occurred, the return value of - cp_parser_parse_definitely will be false, as required. */ - return cp_parser_parse_definitely (parser); - - /* Parse the unqualified-id. */ - identifier = cp_parser_unqualified_id (parser, - /*template_keyword_p=*/false, - /*check_dependency_p=*/true, - /*declarator_p=*/true, - /*optional_p=*/false); - - if (access_declaration_p) - { - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - cp_parser_simulate_error (parser); - if (!cp_parser_parse_definitely (parser)) - return false; - } - - /* The function we call to handle a using-declaration is different - depending on what scope we are in. */ - if (qscope == error_mark_node || identifier == error_mark_node) - ; - else if (TREE_CODE (identifier) != IDENTIFIER_NODE - && TREE_CODE (identifier) != BIT_NOT_EXPR) - /* [namespace.udecl] - - A using declaration shall not name a template-id. */ - error ("a template-id may not appear in a using-declaration"); - else - { - if (at_class_scope_p ()) - { - /* Create the USING_DECL. */ - decl = do_class_using_decl (parser->scope, identifier); - /* Add it to the list of members in this class. */ - finish_member_declaration (decl); - } - else - { - decl = cp_parser_lookup_name_simple (parser, identifier); - if (decl == error_mark_node) - cp_parser_name_lookup_error (parser, identifier, decl, NULL); - else if (!at_namespace_scope_p ()) - do_local_using_decl (decl, qscope, identifier); - else - do_toplevel_using_decl (decl, qscope, identifier); - } - } - - /* Look for the final `;'. */ - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); - - return true; -} - -/* Parse a using-directive. - - using-directive: - using namespace :: [opt] nested-name-specifier [opt] - namespace-name ; */ - -static void -cp_parser_using_directive (cp_parser* parser) -{ - tree namespace_decl; - tree attribs; - - /* Look for the `using' keyword. */ - cp_parser_require_keyword (parser, RID_USING, "`using'"); - /* And the `namespace' keyword. */ - cp_parser_require_keyword (parser, RID_NAMESPACE, "`namespace'"); - /* Look for the optional `::' operator. */ - cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false); - /* And the optional nested-name-specifier. */ - cp_parser_nested_name_specifier_opt (parser, - /*typename_keyword_p=*/false, - /*check_dependency_p=*/true, - /*type_p=*/false, - /*is_declaration=*/true); - /* Get the namespace being used. */ - namespace_decl = cp_parser_namespace_name (parser); - /* And any specified attributes. */ - attribs = cp_parser_attributes_opt (parser); - /* Update the symbol table. */ - parse_using_directive (namespace_decl, attribs); - /* Look for the final `;'. */ - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); -} - -/* Parse an asm-definition. - - asm-definition: - asm ( string-literal ) ; - APPLE LOCAL begin CW asm blocks - asm { asm-line [opt] } - asm asm-line - APPLE LOCAL end CW asm blocks - - GNU Extension: - - asm-definition: - asm volatile [opt] ( string-literal ) ; - asm volatile [opt] ( string-literal : asm-operand-list [opt] ) ; - asm volatile [opt] ( string-literal : asm-operand-list [opt] - : asm-operand-list [opt] ) ; - asm volatile [opt] ( string-literal : asm-operand-list [opt] - : asm-operand-list [opt] - : asm-operand-list [opt] ) ; */ - -static void -/* APPLE LOCAL CW asm blocks */ -cp_parser_asm_definition (cp_parser* parser, bool statement_p ATTRIBUTE_UNUSED) -{ - tree string; - tree outputs = NULL_TREE; - tree inputs = NULL_TREE; - tree clobbers = NULL_TREE; - /* APPLE LOCAL CW asm blocks */ - tree uses = NULL_TREE; - tree asm_stmt; - bool volatile_p = false; - bool extended_p = false; - - /* APPLE LOCAL begin CW asm blocks */ - cp_token *nextup; - /* Detect when a leading `asm' is actually a spec of an asm function - rather than an asm statement or block. */ - if (flag_iasm_blocks) - { - nextup = cp_lexer_peek_nth_token (parser->lexer, 2); - if (statement_p - && nextup->u.value - && IASM_SEE_OPCODE (TYPESPEC, nextup->u.value) == IDENTIFIER) - { - nextup->keyword = RID_MAX; - nextup->type = CPP_NAME; - } - if (!((nextup->type == CPP_OPEN_PAREN) - || (nextup->keyword == RID_VOLATILE - && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_OPEN_PAREN) - || (nextup->type == CPP_OPEN_BRACE) - || (nextup->type == CPP_ATSIGN) - || (nextup->keyword == RID_ASM) - || (nextup->type == CPP_DOT) - || (nextup->type == CPP_SEMICOLON) - || (nextup->flags & BOL) - || (nextup->type == CPP_NAME - && !iasm_typename_or_reserved (nextup->u.value)))) - { - /* An asm function - we'll treat the `asm' as if it were a - storage class spec, which will eventually affect function - body parsing. */ - cp_parser_simple_declaration (parser, true); - return; - } - } - /* APPLE LOCAL end CW asm blocks */ - - /* Look for the `asm' keyword. */ - cp_parser_require_keyword (parser, RID_ASM, "`asm'"); - /* See if the next token is `volatile'. */ - if (cp_parser_allow_gnu_extensions_p (parser) - && cp_lexer_next_token_is_keyword (parser->lexer, RID_VOLATILE)) - { - /* Remember that we saw the `volatile' keyword. */ - volatile_p = true; - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - } - /* APPLE LOCAL begin CW asm blocks */ - /* A CW-style asm block is introduced by an open brace. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) - { - if (flag_iasm_blocks) - cp_parser_iasm_compound_statement (parser); - else - error ("asm blocks not enabled, use `-fasm-blocks'"); - return; - } - if (! volatile_p - && (cp_lexer_next_token_is (parser->lexer, CPP_DOT) - || cp_lexer_next_token_is (parser->lexer, CPP_ATSIGN) - || cp_lexer_next_token_is (parser->lexer, CPP_NAME) - || cp_lexer_next_token_is_keyword (parser->lexer, RID_ASM) - || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON) - || (cp_lexer_iasm_bol (parser->lexer) - && ! cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)))) - { - if (flag_iasm_blocks) - cp_parser_iasm_top_statement (parser); - else - error ("asm blocks not enabled, use `-fasm-blocks'"); - return; - } - - /* APPLE LOCAL end CW asm blocks */ - /* Look for the opening `('. */ - if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - return; - /* Look for the string. */ - string = cp_parser_string_literal (parser, false, false); - if (string == error_mark_node) - { - cp_parser_skip_to_closing_parenthesis (parser, true, false, - /*consume_paren=*/true); - return; - } - - /* If we're allowing GNU extensions, check for the extended assembly - syntax. Unfortunately, the `:' tokens need not be separated by - a space in C, and so, for compatibility, we tolerate that here - too. Doing that means that we have to treat the `::' operator as - two `:' tokens. */ - if (cp_parser_allow_gnu_extensions_p (parser) - && parser->in_function_body - && (cp_lexer_next_token_is (parser->lexer, CPP_COLON) - || cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))) - { - bool inputs_p = false; - bool clobbers_p = false; - - /* The extended syntax was used. */ - extended_p = true; - - /* Look for outputs. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COLON)) - { - /* Consume the `:'. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the output-operands. */ - if (cp_lexer_next_token_is_not (parser->lexer, - CPP_COLON) - && cp_lexer_next_token_is_not (parser->lexer, - CPP_SCOPE) - && cp_lexer_next_token_is_not (parser->lexer, - CPP_CLOSE_PAREN)) - outputs = cp_parser_asm_operand_list (parser); - } - /* If the next token is `::', there are no outputs, and the - next token is the beginning of the inputs. */ - else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)) - /* The inputs are coming next. */ - inputs_p = true; - - /* Look for inputs. */ - if (inputs_p - || cp_lexer_next_token_is (parser->lexer, CPP_COLON)) - { - /* Consume the `:' or `::'. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the output-operands. */ - if (cp_lexer_next_token_is_not (parser->lexer, - CPP_COLON) - && cp_lexer_next_token_is_not (parser->lexer, - CPP_CLOSE_PAREN)) - inputs = cp_parser_asm_operand_list (parser); - } - else if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)) - /* The clobbers are coming next. */ - clobbers_p = true; - - /* Look for clobbers. */ - if (clobbers_p - || cp_lexer_next_token_is (parser->lexer, CPP_COLON)) - { - /* Consume the `:' or `::'. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the clobbers. */ - if (cp_lexer_next_token_is_not (parser->lexer, - CPP_CLOSE_PAREN)) - clobbers = cp_parser_asm_clobber_list (parser); - } - } - /* Look for the closing `)'. */ - if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - cp_parser_skip_to_closing_parenthesis (parser, true, false, - /*consume_paren=*/true); - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); - - /* Create the ASM_EXPR. */ - if (parser->in_function_body) - { - asm_stmt = finish_asm_stmt (volatile_p, string, outputs, - /* APPLE LOCAL CW asm blocks */ - inputs, clobbers, uses); - /* If the extended syntax was not used, mark the ASM_EXPR. */ - if (!extended_p) - { - tree temp = asm_stmt; - if (TREE_CODE (temp) == CLEANUP_POINT_EXPR) - temp = TREE_OPERAND (temp, 0); - - ASM_INPUT_P (temp) = 1; - } - } - else - cgraph_add_asm_node (string); -} - -/* Declarators [gram.dcl.decl] */ - -/* Parse an init-declarator. - - init-declarator: - declarator initializer [opt] - - GNU Extension: - - init-declarator: - declarator asm-specification [opt] attributes [opt] initializer [opt] - - function-definition: - decl-specifier-seq [opt] declarator ctor-initializer [opt] - function-body - decl-specifier-seq [opt] declarator function-try-block - - GNU Extension: - - function-definition: - __extension__ function-definition - - The DECL_SPECIFIERS apply to this declarator. Returns a - representation of the entity declared. If MEMBER_P is TRUE, then - this declarator appears in a class scope. The new DECL created by - this declarator is returned. - - The CHECKS are access checks that should be performed once we know - what entity is being declared (and, therefore, what classes have - befriended it). - - If FUNCTION_DEFINITION_ALLOWED_P then we handle the declarator and - for a function-definition here as well. If the declarator is a - declarator for a function-definition, *FUNCTION_DEFINITION_P will - be TRUE upon return. By that point, the function-definition will - have been completely parsed. - - FUNCTION_DEFINITION_P may be NULL if FUNCTION_DEFINITION_ALLOWED_P - is FALSE. */ - -static tree -cp_parser_init_declarator (cp_parser* parser, - cp_decl_specifier_seq *decl_specifiers, - VEC (deferred_access_check,gc)* checks, - bool function_definition_allowed_p, - bool member_p, - int declares_class_or_enum, - bool* function_definition_p) -{ - cp_token *token; - cp_declarator *declarator; - tree prefix_attributes; - tree attributes; - tree asm_specification; - tree initializer; - tree decl = NULL_TREE; - tree scope; - bool is_initialized; - /* Only valid if IS_INITIALIZED is true. In that case, CPP_EQ if - initialized with "= ..", CPP_OPEN_PAREN if initialized with - "(...)". */ - enum cpp_ttype initialization_kind; - bool is_parenthesized_init = false; - bool is_non_constant_init; - int ctor_dtor_or_conv_p; - bool friend_p; - tree pushed_scope = NULL; - - /* Gather the attributes that were provided with the - decl-specifiers. */ - prefix_attributes = decl_specifiers->attributes; - - /* Assume that this is not the declarator for a function - definition. */ - if (function_definition_p) - *function_definition_p = false; - - /* Defer access checks while parsing the declarator; we cannot know - what names are accessible until we know what is being - declared. */ - resume_deferring_access_checks (); - - /* Parse the declarator. */ - declarator - = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED, - &ctor_dtor_or_conv_p, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - /* Gather up the deferred checks. */ - stop_deferring_access_checks (); - - /* If the DECLARATOR was erroneous, there's no need to go - further. */ - if (declarator == cp_error_declarator) - return error_mark_node; - - /* Check that the number of template-parameter-lists is OK. */ - if (!cp_parser_check_declarator_template_parameters (parser, declarator)) - return error_mark_node; - - if (declares_class_or_enum & 2) - cp_parser_check_for_definition_in_return_type (declarator, - decl_specifiers->type); - - /* Figure out what scope the entity declared by the DECLARATOR is - located in. `grokdeclarator' sometimes changes the scope, so - we compute it now. */ - scope = get_scope_of_declarator (declarator); - - /* If we're allowing GNU extensions, look for an asm-specification - and attributes. */ - if (cp_parser_allow_gnu_extensions_p (parser)) - { - /* Look for an asm-specification. */ - asm_specification = cp_parser_asm_specification_opt (parser); - /* And attributes. */ - attributes = cp_parser_attributes_opt (parser); - } - else - { - asm_specification = NULL_TREE; - attributes = NULL_TREE; - } - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Check to see if the token indicates the start of a - function-definition. */ - if (cp_parser_token_starts_function_definition_p (token)) - { - if (!function_definition_allowed_p) - { - /* If a function-definition should not appear here, issue an - error message. */ - cp_parser_error (parser, - "a function-definition is not allowed here"); - return error_mark_node; - } - else - { - /* Neither attributes nor an asm-specification are allowed - on a function-definition. */ - if (asm_specification) - error ("an asm-specification is not allowed on a function-definition"); - if (attributes) - error ("attributes are not allowed on a function-definition"); - /* This is a function-definition. */ - *function_definition_p = true; - - /* Parse the function definition. */ - if (member_p) - decl = cp_parser_save_member_function_body (parser, - decl_specifiers, - declarator, - prefix_attributes); - else - decl - = (cp_parser_function_definition_from_specifiers_and_declarator - (parser, decl_specifiers, prefix_attributes, declarator)); - - return decl; - } - } - - /* [dcl.dcl] - - Only in function declarations for constructors, destructors, and - type conversions can the decl-specifier-seq be omitted. - - We explicitly postpone this check past the point where we handle - function-definitions because we tolerate function-definitions - that are missing their return types in some modes. */ - if (!decl_specifiers->any_specifiers_p && ctor_dtor_or_conv_p <= 0) - { - cp_parser_error (parser, - "expected constructor, destructor, or type conversion"); - return error_mark_node; - } - - /* An `=' or an `(' indicates an initializer. */ - if (token->type == CPP_EQ - || token->type == CPP_OPEN_PAREN) - { - is_initialized = true; - initialization_kind = token->type; - } - else - { - /* If the init-declarator isn't initialized and isn't followed by a - `,' or `;', it's not a valid init-declarator. */ - if (token->type != CPP_COMMA - && token->type != CPP_SEMICOLON) - { - cp_parser_error (parser, "expected initializer"); - return error_mark_node; - } - is_initialized = false; - initialization_kind = CPP_EOF; - } - - /* Because start_decl has side-effects, we should only call it if we - know we're going ahead. By this point, we know that we cannot - possibly be looking at any other construct. */ - cp_parser_commit_to_tentative_parse (parser); - - /* If the decl specifiers were bad, issue an error now that we're - sure this was intended to be a declarator. Then continue - declaring the variable(s), as int, to try to cut down on further - errors. */ - if (decl_specifiers->any_specifiers_p - && decl_specifiers->type == error_mark_node) - { - cp_parser_error (parser, "invalid type in declaration"); - decl_specifiers->type = integer_type_node; - } - - /* Check to see whether or not this declaration is a friend. */ - friend_p = cp_parser_friend_p (decl_specifiers); - - /* Enter the newly declared entry in the symbol table. If we're - processing a declaration in a class-specifier, we wait until - after processing the initializer. */ - if (!member_p) - { - if (parser->in_unbraced_linkage_specification_p) - decl_specifiers->storage_class = sc_extern; - decl = start_decl (declarator, decl_specifiers, - is_initialized, attributes, prefix_attributes, - &pushed_scope); - } - else if (scope) - /* Enter the SCOPE. That way unqualified names appearing in the - initializer will be looked up in SCOPE. */ - pushed_scope = push_scope (scope); - - /* Perform deferred access control checks, now that we know in which - SCOPE the declared entity resides. */ - if (!member_p && decl) - { - tree saved_current_function_decl = NULL_TREE; - - /* If the entity being declared is a function, pretend that we - are in its scope. If it is a `friend', it may have access to - things that would not otherwise be accessible. */ - if (TREE_CODE (decl) == FUNCTION_DECL) - { - saved_current_function_decl = current_function_decl; - current_function_decl = decl; - } - - /* Perform access checks for template parameters. */ - cp_parser_perform_template_parameter_access_checks (checks); - - /* Perform the access control checks for the declarator and the - the decl-specifiers. */ - perform_deferred_access_checks (); - - /* Restore the saved value. */ - if (TREE_CODE (decl) == FUNCTION_DECL) - current_function_decl = saved_current_function_decl; - } - - /* Parse the initializer. */ - initializer = NULL_TREE; - is_parenthesized_init = false; - is_non_constant_init = true; - if (is_initialized) - { - if (function_declarator_p (declarator)) - { - if (initialization_kind == CPP_EQ) - initializer = cp_parser_pure_specifier (parser); - else - { - /* If the declaration was erroneous, we don't really - know what the user intended, so just silently - consume the initializer. */ - if (decl != error_mark_node) - error ("initializer provided for function"); - cp_parser_skip_to_closing_parenthesis (parser, - /*recovering=*/true, - /*or_comma=*/false, - /*consume_paren=*/true); - } - } - else - initializer = cp_parser_initializer (parser, - &is_parenthesized_init, - &is_non_constant_init); - } - - /* The old parser allows attributes to appear after a parenthesized - initializer. Mark Mitchell proposed removing this functionality - on the GCC mailing lists on 2002-08-13. This parser accepts the - attributes -- but ignores them. */ - if (cp_parser_allow_gnu_extensions_p (parser) && is_parenthesized_init) - if (cp_parser_attributes_opt (parser)) - warning (OPT_Wattributes, - "attributes after parenthesized initializer ignored"); - - /* For an in-class declaration, use `grokfield' to create the - declaration. */ - if (member_p) - { - if (pushed_scope) - { - pop_scope (pushed_scope); - pushed_scope = false; - } - decl = grokfield (declarator, decl_specifiers, - initializer, !is_non_constant_init, - /*asmspec=*/NULL_TREE, - prefix_attributes); - if (decl && TREE_CODE (decl) == FUNCTION_DECL) - cp_parser_save_default_args (parser, decl); - } - - /* Finish processing the declaration. But, skip friend - declarations. */ - if (!friend_p && decl && decl != error_mark_node) - { - cp_finish_decl (decl, - initializer, !is_non_constant_init, - asm_specification, - /* If the initializer is in parentheses, then this is - a direct-initialization, which means that an - `explicit' constructor is OK. Otherwise, an - `explicit' constructor cannot be used. */ - ((is_parenthesized_init || !is_initialized) - ? 0 : LOOKUP_ONLYCONVERTING)); - } - if (!friend_p && pushed_scope) - pop_scope (pushed_scope); - - return decl; -} - -/* APPLE LOCAL begin blocks 6040305 (cc) */ -static cp_cv_quals -cp_parser_cv_qualifier_or_attribute_seq_opt (cp_parser *parser, tree *attrs_p) -{ - cp_cv_quals quals = TYPE_UNQUALIFIED; - cp_cv_quals q; - cp_token *token; - - *attrs_p = NULL_TREE; - while (true) - { - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Handle attributes. */ - if (token->keyword == RID_ATTRIBUTE) - { - /* Parse the attributes. */ - *attrs_p = chainon (*attrs_p, - cp_parser_attributes_opt (parser)); - continue; - } - - q = cp_parser_cv_qualifier_seq_opt (parser); - if (q == TYPE_UNQUALIFIED) - break; - quals |= q; - } - return quals; -} -/* APPLE LOCAL end blocks 6040305 (cc) */ - -/* Parse a declarator. - - declarator: - direct-declarator - ptr-operator declarator - - abstract-declarator: - ptr-operator abstract-declarator [opt] - direct-abstract-declarator - - GNU Extensions: - - declarator: - attributes [opt] direct-declarator - attributes [opt] ptr-operator declarator - - abstract-declarator: - attributes [opt] ptr-operator abstract-declarator [opt] - attributes [opt] direct-abstract-declarator - - APPLE LOCAL begin blocks 6339747 - block-declarator: - attributes [opt] ptr-operator block-declarator [opt] - attributes [opt] direct-block-declarator - APPLE LOCAL end blocks 6339747 - - If CTOR_DTOR_OR_CONV_P is not NULL, *CTOR_DTOR_OR_CONV_P is used to - detect constructor, destructor or conversion operators. It is set - to -1 if the declarator is a name, and +1 if it is a - function. Otherwise it is set to zero. Usually you just want to - test for >0, but internally the negative value is used. - - (The reason for CTOR_DTOR_OR_CONV_P is that a declaration must have - a decl-specifier-seq unless it declares a constructor, destructor, - or conversion. It might seem that we could check this condition in - semantic analysis, rather than parsing, but that makes it difficult - to handle something like `f()'. We want to notice that there are - no decl-specifiers, and therefore realize that this is an - expression, not a declaration.) - - If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to true iff - the declarator is a direct-declarator of the form "(...)". - - MEMBER_P is true iff this declarator is a member-declarator. */ - -static cp_declarator * -cp_parser_declarator (cp_parser* parser, - cp_parser_declarator_kind dcl_kind, - int* ctor_dtor_or_conv_p, - bool* parenthesized_p, - bool member_p) -{ - cp_token *token; - cp_declarator *declarator; - enum tree_code code; - cp_cv_quals cv_quals; - tree class_type; - tree attributes = NULL_TREE; - - /* Assume this is not a constructor, destructor, or type-conversion - operator. */ - if (ctor_dtor_or_conv_p) - *ctor_dtor_or_conv_p = 0; - - if (cp_parser_allow_gnu_extensions_p (parser)) - attributes = cp_parser_attributes_opt (parser); - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - - /* APPLE LOCAL begin blocks 6040305 (cc) */ - if (flag_blocks && token->type == CPP_XOR) - { - cp_cv_quals quals; - cp_declarator *inner; - tree attrs; - - cp_lexer_consume_token (parser->lexer); - - /* cp_parse_declspecs (parser, quals_attrs, false, false, true); */ - quals = cp_parser_cv_qualifier_or_attribute_seq_opt (parser, &attrs); - - inner = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER, - /*ctor_dtor_or_conv_p=*/NULL, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - if (inner == cp_error_declarator) - return inner; - return make_block_pointer_declarator (attrs, quals, inner); - } - /* APPLE LOCAL end blocks 6040305 (cc) */ - - /* Check for the ptr-operator production. */ - cp_parser_parse_tentatively (parser); - /* Parse the ptr-operator. */ - code = cp_parser_ptr_operator (parser, - &class_type, - &cv_quals); - /* If that worked, then we have a ptr-operator. */ - if (cp_parser_parse_definitely (parser)) - { - /* If a ptr-operator was found, then this declarator was not - parenthesized. */ - if (parenthesized_p) - *parenthesized_p = true; - /* The dependent declarator is optional if we are parsing an - abstract-declarator. */ - if (dcl_kind != CP_PARSER_DECLARATOR_NAMED) - cp_parser_parse_tentatively (parser); - - /* Parse the dependent declarator. */ - declarator = cp_parser_declarator (parser, dcl_kind, - /*ctor_dtor_or_conv_p=*/NULL, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - - /* If we are parsing an abstract-declarator, we must handle the - case where the dependent declarator is absent. */ - if (dcl_kind != CP_PARSER_DECLARATOR_NAMED - && !cp_parser_parse_definitely (parser)) - declarator = NULL; - - /* Build the representation of the ptr-operator. */ - if (class_type) - declarator = make_ptrmem_declarator (cv_quals, - class_type, - declarator); - else if (code == INDIRECT_REF) - declarator = make_pointer_declarator (cv_quals, declarator); - else - declarator = make_reference_declarator (cv_quals, declarator); - } - /* Everything else is a direct-declarator. */ - else - { - if (parenthesized_p) - *parenthesized_p = cp_lexer_next_token_is (parser->lexer, - CPP_OPEN_PAREN); - declarator = cp_parser_direct_declarator (parser, dcl_kind, - ctor_dtor_or_conv_p, - member_p); - } - - if (attributes && declarator && declarator != cp_error_declarator) - declarator->attributes = attributes; - - return declarator; -} - -/* Parse a direct-declarator or direct-abstract-declarator. - - direct-declarator: - declarator-id - direct-declarator ( parameter-declaration-clause ) - cv-qualifier-seq [opt] - exception-specification [opt] - direct-declarator [ constant-expression [opt] ] - ( declarator ) - - direct-abstract-declarator: - direct-abstract-declarator [opt] - ( parameter-declaration-clause ) - cv-qualifier-seq [opt] - exception-specification [opt] - direct-abstract-declarator [opt] [ constant-expression [opt] ] - ( abstract-declarator ) - - APPLE LOCAL begin blocks 6339747 - GNU Extensions: - - direct-block-declarator: - direct-block-declarator [opt] - ( parameter-declaration-clause ) [opt] - exception-specification [opt] - direct-block-declarator [opt] [ constant-expression [opt] ] - ( block-declarator ) - APPLE LOCAL end blocks 6339747 - - Returns a representation of the declarator. DCL_KIND is - CP_PARSER_DECLARATOR_ABSTRACT, if we are parsing a - direct-abstract-declarator. It is CP_PARSER_DECLARATOR_NAMED, if - we are parsing a direct-declarator. It is - CP_PARSER_DECLARATOR_EITHER, if we can accept either - in the case - of ambiguity we prefer an abstract declarator, as per - [dcl.ambig.res]. CTOR_DTOR_OR_CONV_P and MEMBER_P are as for - cp_parser_declarator. */ - -static cp_declarator * -cp_parser_direct_declarator (cp_parser* parser, - cp_parser_declarator_kind dcl_kind, - int* ctor_dtor_or_conv_p, - bool member_p) -{ - cp_token *token; - cp_declarator *declarator = NULL; - tree scope = NULL_TREE; - bool saved_default_arg_ok_p = parser->default_arg_ok_p; - bool saved_in_declarator_p = parser->in_declarator_p; - bool first = true; - tree pushed_scope = NULL_TREE; - - while (true) - { - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - if (token->type == CPP_OPEN_PAREN) - { - /* This is either a parameter-declaration-clause, or a - parenthesized declarator. When we know we are parsing a - named declarator, it must be a parenthesized declarator - if FIRST is true. For instance, `(int)' is a - parameter-declaration-clause, with an omitted - direct-abstract-declarator. But `((*))', is a - parenthesized abstract declarator. Finally, when T is a - template parameter `(T)' is a - parameter-declaration-clause, and not a parenthesized - named declarator. - - We first try and parse a parameter-declaration-clause, - and then try a nested declarator (if FIRST is true). - - It is not an error for it not to be a - parameter-declaration-clause, even when FIRST is - false. Consider, - - int i (int); - int i (3); - - The first is the declaration of a function while the - second is a the definition of a variable, including its - initializer. - - Having seen only the parenthesis, we cannot know which of - these two alternatives should be selected. Even more - complex are examples like: - - int i (int (a)); - int i (int (3)); - - The former is a function-declaration; the latter is a - variable initialization. - - Thus again, we try a parameter-declaration-clause, and if - that fails, we back out and return. */ - - if (!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED) - { - cp_parameter_declarator *params; - unsigned saved_num_template_parameter_lists; - - /* In a member-declarator, the only valid interpretation - of a parenthesis is the start of a - parameter-declaration-clause. (It is invalid to - initialize a static data member with a parenthesized - initializer; only the "=" form of initialization is - permitted.) */ - if (!member_p) - cp_parser_parse_tentatively (parser); - - /* Consume the `('. */ - cp_lexer_consume_token (parser->lexer); - if (first) - { - /* If this is going to be an abstract declarator, we're - in a declarator and we can't have default args. */ - parser->default_arg_ok_p = false; - parser->in_declarator_p = true; - } - - /* Inside the function parameter list, surrounding - template-parameter-lists do not apply. */ - saved_num_template_parameter_lists - = parser->num_template_parameter_lists; - parser->num_template_parameter_lists = 0; - - /* Parse the parameter-declaration-clause. */ - params = cp_parser_parameter_declaration_clause (parser); - - parser->num_template_parameter_lists - = saved_num_template_parameter_lists; - - /* If all went well, parse the cv-qualifier-seq and the - exception-specification. */ - if (member_p || cp_parser_parse_definitely (parser)) - { - cp_cv_quals cv_quals; - tree exception_specification; - - if (ctor_dtor_or_conv_p) - *ctor_dtor_or_conv_p = *ctor_dtor_or_conv_p < 0; - first = false; - /* Consume the `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - /* APPLE LOCAL begin blocks 6339747 */ - if (dcl_kind != BLOCKDEF) - { - /* Parse the cv-qualifier-seq. */ - cv_quals = cp_parser_cv_qualifier_seq_opt (parser); - } - else - cv_quals = TYPE_UNQUALIFIED; - /* APPLE LOCAL end blocks 6339747 */ - - /* And the exception-specification. */ - exception_specification - = cp_parser_exception_specification_opt (parser); - - /* Create the function-declarator. */ - declarator = make_call_declarator (declarator, - params, - cv_quals, - exception_specification); - /* Any subsequent parameter lists are to do with - return type, so are not those of the declared - function. */ - parser->default_arg_ok_p = false; - - /* Repeat the main loop. */ - continue; - } - } - - /* If this is the first, we can try a parenthesized - declarator. */ - if (first) - { - bool saved_in_type_id_in_expr_p; - - parser->default_arg_ok_p = saved_default_arg_ok_p; - parser->in_declarator_p = saved_in_declarator_p; - - /* Consume the `('. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the nested declarator. */ - saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p; - parser->in_type_id_in_expr_p = true; - declarator - = cp_parser_declarator (parser, dcl_kind, ctor_dtor_or_conv_p, - /*parenthesized_p=*/NULL, - member_p); - parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p; - first = false; - /* Expect a `)'. */ - if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - declarator = cp_error_declarator; - if (declarator == cp_error_declarator) - break; - - goto handle_declarator; - } - /* Otherwise, we must be done. */ - else - break; - } - else if ((!first || dcl_kind != CP_PARSER_DECLARATOR_NAMED) - && token->type == CPP_OPEN_SQUARE) - { - /* Parse an array-declarator. */ - tree bounds; - - if (ctor_dtor_or_conv_p) - *ctor_dtor_or_conv_p = 0; - - first = false; - parser->default_arg_ok_p = false; - parser->in_declarator_p = true; - /* Consume the `['. */ - cp_lexer_consume_token (parser->lexer); - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If the next token is `]', then there is no - constant-expression. */ - if (token->type != CPP_CLOSE_SQUARE) - { - bool non_constant_p; - - bounds - = cp_parser_constant_expression (parser, - /*allow_non_constant=*/true, - &non_constant_p); - if (!non_constant_p) - bounds = fold_non_dependent_expr (bounds); - /* Normally, the array bound must be an integral constant - expression. However, as an extension, we allow VLAs - in function scopes. */ - else if (!parser->in_function_body) - { - error ("array bound is not an integer constant"); - bounds = error_mark_node; - } - } - else - bounds = NULL_TREE; - /* Look for the closing `]'. */ - if (!cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'")) - { - declarator = cp_error_declarator; - break; - } - - declarator = make_array_declarator (declarator, bounds); - } - /* APPLE LOCAL begin blocks 6339747 */ - else if (first && (dcl_kind == CP_PARSER_DECLARATOR_NAMED - || dcl_kind == CP_PARSER_DECLARATOR_EITHER)) - /* APPLE LOCAL end blocks 6339747 */ - { - tree qualifying_scope; - tree unqualified_name; - special_function_kind sfk; - bool abstract_ok; - - /* Parse a declarator-id */ - abstract_ok = (dcl_kind == CP_PARSER_DECLARATOR_EITHER); - if (abstract_ok) - cp_parser_parse_tentatively (parser); - unqualified_name - = cp_parser_declarator_id (parser, /*optional_p=*/abstract_ok); - qualifying_scope = parser->scope; - if (abstract_ok) - { - if (!cp_parser_parse_definitely (parser)) - unqualified_name = error_mark_node; - else if (unqualified_name - && (qualifying_scope - || (TREE_CODE (unqualified_name) - != IDENTIFIER_NODE))) - { - cp_parser_error (parser, "expected unqualified-id"); - unqualified_name = error_mark_node; - } - } - - if (!unqualified_name) - return NULL; - if (unqualified_name == error_mark_node) - { - declarator = cp_error_declarator; - break; - } - - if (qualifying_scope && at_namespace_scope_p () - && TREE_CODE (qualifying_scope) == TYPENAME_TYPE) - { - /* In the declaration of a member of a template class - outside of the class itself, the SCOPE will sometimes - be a TYPENAME_TYPE. For example, given: - - template <typename T> - int S<T>::R::i = 3; - - the SCOPE will be a TYPENAME_TYPE for `S<T>::R'. In - this context, we must resolve S<T>::R to an ordinary - type, rather than a typename type. - - The reason we normally avoid resolving TYPENAME_TYPEs - is that a specialization of `S' might render - `S<T>::R' not a type. However, if `S' is - specialized, then this `i' will not be used, so there - is no harm in resolving the types here. */ - tree type; - - /* Resolve the TYPENAME_TYPE. */ - type = resolve_typename_type (qualifying_scope, - /*only_current_p=*/false); - /* If that failed, the declarator is invalid. */ - if (type == error_mark_node) - error ("%<%T::%D%> is not a type", - TYPE_CONTEXT (qualifying_scope), - TYPE_IDENTIFIER (qualifying_scope)); - qualifying_scope = type; - } - - sfk = sfk_none; - if (unqualified_name) - { - tree class_type; - - if (qualifying_scope - && CLASS_TYPE_P (qualifying_scope)) - class_type = qualifying_scope; - else - class_type = current_class_type; - - if (TREE_CODE (unqualified_name) == TYPE_DECL) - { - tree name_type = TREE_TYPE (unqualified_name); - if (class_type && same_type_p (name_type, class_type)) - { - if (qualifying_scope - && CLASSTYPE_USE_TEMPLATE (name_type)) - { - error ("invalid use of constructor as a template"); - inform ("use %<%T::%D%> instead of %<%T::%D%> to " - "name the constructor in a qualified name", - class_type, - DECL_NAME (TYPE_TI_TEMPLATE (class_type)), - class_type, name_type); - declarator = cp_error_declarator; - break; - } - else - unqualified_name = constructor_name (class_type); - } - else - { - /* We do not attempt to print the declarator - here because we do not have enough - information about its original syntactic - form. */ - cp_parser_error (parser, "invalid declarator"); - declarator = cp_error_declarator; - break; - } - } - - if (class_type) - { - if (TREE_CODE (unqualified_name) == BIT_NOT_EXPR) - sfk = sfk_destructor; - else if (IDENTIFIER_TYPENAME_P (unqualified_name)) - sfk = sfk_conversion; - else if (/* There's no way to declare a constructor - for an anonymous type, even if the type - got a name for linkage purposes. */ - !TYPE_WAS_ANONYMOUS (class_type) - && constructor_name_p (unqualified_name, - class_type)) - { - unqualified_name = constructor_name (class_type); - sfk = sfk_constructor; - } - - if (ctor_dtor_or_conv_p && sfk != sfk_none) - *ctor_dtor_or_conv_p = -1; - } - } - declarator = make_id_declarator (qualifying_scope, - unqualified_name, - sfk); - declarator->id_loc = token->location; - - handle_declarator:; - scope = get_scope_of_declarator (declarator); - if (scope) - /* Any names that appear after the declarator-id for a - member are looked up in the containing scope. */ - pushed_scope = push_scope (scope); - parser->in_declarator_p = true; - if ((ctor_dtor_or_conv_p && *ctor_dtor_or_conv_p) - || (declarator && declarator->kind == cdk_id)) - /* Default args are only allowed on function - declarations. */ - parser->default_arg_ok_p = saved_default_arg_ok_p; - else - parser->default_arg_ok_p = false; - - first = false; - } - /* We're done. */ - else - break; - } - - /* For an abstract declarator, we might wind up with nothing at this - point. That's an error; the declarator is not optional. */ - /* APPLE LOCAL blocks 6339747 */ - if (!declarator && dcl_kind != CP_PARSER_DECLARATOR_BLOCK) - cp_parser_error (parser, "expected declarator"); - - /* If we entered a scope, we must exit it now. */ - if (pushed_scope) - pop_scope (pushed_scope); - - parser->default_arg_ok_p = saved_default_arg_ok_p; - parser->in_declarator_p = saved_in_declarator_p; - - return declarator; -} - -/* Parse a ptr-operator. - - ptr-operator: - * cv-qualifier-seq [opt] - & - :: [opt] nested-name-specifier * cv-qualifier-seq [opt] - - GNU Extension: - - ptr-operator: - & cv-qualifier-seq [opt] - APPLE LOCAL blocks 6040305 (cc) - ^ - - Returns INDIRECT_REF if a pointer, or pointer-to-member, was used. - Returns ADDR_EXPR if a reference was used. In the case of a - pointer-to-member, *TYPE is filled in with the TYPE containing the - member. *CV_QUALS is filled in with the cv-qualifier-seq, or - TYPE_UNQUALIFIED, if there are no cv-qualifiers. Returns - ERROR_MARK if an error occurred. */ - -static enum tree_code -cp_parser_ptr_operator (cp_parser* parser, - tree* type, - cp_cv_quals *cv_quals) -{ - enum tree_code code = ERROR_MARK; - cp_token *token; - - /* Assume that it's not a pointer-to-member. */ - *type = NULL_TREE; - /* And that there are no cv-qualifiers. */ - *cv_quals = TYPE_UNQUALIFIED; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's a `*' or `&' we have a pointer or reference. */ - if (token->type == CPP_MULT || token->type == CPP_AND) - { - /* Remember which ptr-operator we were processing. */ - code = (token->type == CPP_AND ? ADDR_EXPR : INDIRECT_REF); - - /* Consume the `*' or `&'. */ - cp_lexer_consume_token (parser->lexer); - - /* A `*' can be followed by a cv-qualifier-seq, and so can a - `&', if we are allowing GNU extensions. (The only qualifier - that can legally appear after `&' is `restrict', but that is - enforced during semantic analysis. */ - if (code == INDIRECT_REF - || cp_parser_allow_gnu_extensions_p (parser)) - *cv_quals = cp_parser_cv_qualifier_seq_opt (parser); - } - else - { - /* Try the pointer-to-member case. */ - cp_parser_parse_tentatively (parser); - /* Look for the optional `::' operator. */ - cp_parser_global_scope_opt (parser, - /*current_scope_valid_p=*/false); - /* Look for the nested-name specifier. */ - cp_parser_nested_name_specifier (parser, - /*typename_keyword_p=*/false, - /*check_dependency_p=*/true, - /*type_p=*/false, - /*is_declaration=*/false); - /* If we found it, and the next token is a `*', then we are - indeed looking at a pointer-to-member operator. */ - if (!cp_parser_error_occurred (parser) - && cp_parser_require (parser, CPP_MULT, "`*'")) - { - /* Indicate that the `*' operator was used. */ - code = INDIRECT_REF; - - if (TREE_CODE (parser->scope) == NAMESPACE_DECL) - error ("%qD is a namespace", parser->scope); - else - { - /* The type of which the member is a member is given by the - current SCOPE. */ - *type = parser->scope; - /* The next name will not be qualified. */ - parser->scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - /* Look for the optional cv-qualifier-seq. */ - *cv_quals = cp_parser_cv_qualifier_seq_opt (parser); - } - } - /* If that didn't work we don't have a ptr-operator. */ - if (!cp_parser_parse_definitely (parser)) - cp_parser_error (parser, "expected ptr-operator"); - } - - return code; -} - -/* Parse an (optional) cv-qualifier-seq. - - cv-qualifier-seq: - cv-qualifier cv-qualifier-seq [opt] - - cv-qualifier: - const - volatile - - GNU Extension: - - cv-qualifier: - __restrict__ - - Returns a bitmask representing the cv-qualifiers. */ - -static cp_cv_quals -cp_parser_cv_qualifier_seq_opt (cp_parser* parser) -{ - cp_cv_quals cv_quals = TYPE_UNQUALIFIED; - - while (true) - { - cp_token *token; - cp_cv_quals cv_qualifier; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* See if it's a cv-qualifier. */ - switch (token->keyword) - { - case RID_CONST: - cv_qualifier = TYPE_QUAL_CONST; - break; - - case RID_VOLATILE: - cv_qualifier = TYPE_QUAL_VOLATILE; - break; - - case RID_RESTRICT: - cv_qualifier = TYPE_QUAL_RESTRICT; - break; - - default: - cv_qualifier = TYPE_UNQUALIFIED; - break; - } - - if (!cv_qualifier) - break; - - if (cv_quals & cv_qualifier) - { - error ("duplicate cv-qualifier"); - cp_lexer_purge_token (parser->lexer); - } - else - { - cp_lexer_consume_token (parser->lexer); - cv_quals |= cv_qualifier; - } - } - - return cv_quals; -} - -/* Parse a declarator-id. - - declarator-id: - id-expression - :: [opt] nested-name-specifier [opt] type-name - - In the `id-expression' case, the value returned is as for - cp_parser_id_expression if the id-expression was an unqualified-id. - If the id-expression was a qualified-id, then a SCOPE_REF is - returned. The first operand is the scope (either a NAMESPACE_DECL - or TREE_TYPE), but the second is still just a representation of an - unqualified-id. */ - -static tree -cp_parser_declarator_id (cp_parser* parser, bool optional_p) -{ - tree id; - /* The expression must be an id-expression. Assume that qualified - names are the names of types so that: - - template <class T> - int S<T>::R::i = 3; - - will work; we must treat `S<T>::R' as the name of a type. - Similarly, assume that qualified names are templates, where - required, so that: - - template <class T> - int S<T>::R<T>::i = 3; - - will work, too. */ - id = cp_parser_id_expression (parser, - /*template_keyword_p=*/false, - /*check_dependency_p=*/false, - /*template_p=*/NULL, - /*declarator_p=*/true, - optional_p); - if (id && BASELINK_P (id)) - id = BASELINK_FUNCTIONS (id); - return id; -} - -/* Parse a type-id. - - type-id: - type-specifier-seq abstract-declarator [opt] - - Returns the TYPE specified. */ - -static tree -cp_parser_type_id (cp_parser* parser) -{ - cp_decl_specifier_seq type_specifier_seq; - cp_declarator *abstract_declarator; - - /* Parse the type-specifier-seq. */ - cp_parser_type_specifier_seq (parser, /*is_condition=*/false, - &type_specifier_seq); - if (type_specifier_seq.type == error_mark_node) - return error_mark_node; - - /* There might or might not be an abstract declarator. */ - cp_parser_parse_tentatively (parser); - /* Look for the declarator. */ - abstract_declarator - = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_ABSTRACT, NULL, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - /* Check to see if there really was a declarator. */ - if (!cp_parser_parse_definitely (parser)) - abstract_declarator = NULL; - - return groktypename (&type_specifier_seq, abstract_declarator); -} - -/* Parse a type-specifier-seq. - - type-specifier-seq: - type-specifier type-specifier-seq [opt] - - GNU extension: - - type-specifier-seq: - attributes type-specifier-seq [opt] - - If IS_CONDITION is true, we are at the start of a "condition", - e.g., we've just seen "if (". - - Sets *TYPE_SPECIFIER_SEQ to represent the sequence. */ - -static void -cp_parser_type_specifier_seq (cp_parser* parser, - bool is_condition, - cp_decl_specifier_seq *type_specifier_seq) -{ - bool seen_type_specifier = false; - cp_parser_flags flags = CP_PARSER_FLAGS_OPTIONAL; - - /* Clear the TYPE_SPECIFIER_SEQ. */ - clear_decl_specs (type_specifier_seq); - - /* Parse the type-specifiers and attributes. */ - while (true) - { - tree type_specifier; - bool is_cv_qualifier; - - /* Check for attributes first. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE)) - { - type_specifier_seq->attributes = - chainon (type_specifier_seq->attributes, - cp_parser_attributes_opt (parser)); - continue; - } - - /* Look for the type-specifier. */ - type_specifier = cp_parser_type_specifier (parser, - flags, - type_specifier_seq, - /*is_declaration=*/false, - NULL, - &is_cv_qualifier); - if (!type_specifier) - { - /* If the first type-specifier could not be found, this is not a - type-specifier-seq at all. */ - if (!seen_type_specifier) - { - cp_parser_error (parser, "expected type-specifier"); - type_specifier_seq->type = error_mark_node; - return; - } - /* If subsequent type-specifiers could not be found, the - type-specifier-seq is complete. */ - break; - } - - seen_type_specifier = true; - /* The standard says that a condition can be: - - type-specifier-seq declarator = assignment-expression - - However, given: - - struct S {}; - if (int S = ...) - - we should treat the "S" as a declarator, not as a - type-specifier. The standard doesn't say that explicitly for - type-specifier-seq, but it does say that for - decl-specifier-seq in an ordinary declaration. Perhaps it - would be clearer just to allow a decl-specifier-seq here, and - then add a semantic restriction that if any decl-specifiers - that are not type-specifiers appear, the program is invalid. */ - if (is_condition && !is_cv_qualifier) - flags |= CP_PARSER_FLAGS_NO_USER_DEFINED_TYPES; - } - - cp_parser_check_decl_spec (type_specifier_seq); -} - -/* Parse a parameter-declaration-clause. - - parameter-declaration-clause: - parameter-declaration-list [opt] ... [opt] - parameter-declaration-list , ... - - Returns a representation for the parameter declarations. A return - value of NULL indicates a parameter-declaration-clause consisting - only of an ellipsis. */ - -static cp_parameter_declarator * -cp_parser_parameter_declaration_clause (cp_parser* parser) -{ - cp_parameter_declarator *parameters; - cp_token *token; - bool ellipsis_p; - bool is_error; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Check for trivial parameter-declaration-clauses. */ - if (token->type == CPP_ELLIPSIS) - { - /* Consume the `...' token. */ - cp_lexer_consume_token (parser->lexer); - return NULL; - } - else if (token->type == CPP_CLOSE_PAREN) - /* There are no parameters. */ - { -#ifndef NO_IMPLICIT_EXTERN_C - if (in_system_header && current_class_type == NULL - && current_lang_name == lang_name_c) - return NULL; - else -#endif - return no_parameters; - } - /* Check for `(void)', too, which is a special case. */ - else if (token->keyword == RID_VOID - && (cp_lexer_peek_nth_token (parser->lexer, 2)->type - == CPP_CLOSE_PAREN)) - { - /* Consume the `void' token. */ - cp_lexer_consume_token (parser->lexer); - /* There are no parameters. */ - return no_parameters; - } - - /* Parse the parameter-declaration-list. */ - parameters = cp_parser_parameter_declaration_list (parser, &is_error); - /* If a parse error occurred while parsing the - parameter-declaration-list, then the entire - parameter-declaration-clause is erroneous. */ - if (is_error) - return NULL; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's a `,', the clause should terminate with an ellipsis. */ - if (token->type == CPP_COMMA) - { - /* Consume the `,'. */ - cp_lexer_consume_token (parser->lexer); - /* Expect an ellipsis. */ - ellipsis_p - = (cp_parser_require (parser, CPP_ELLIPSIS, "`...'") != NULL); - } - /* It might also be `...' if the optional trailing `,' was - omitted. */ - else if (token->type == CPP_ELLIPSIS) - { - /* Consume the `...' token. */ - cp_lexer_consume_token (parser->lexer); - /* And remember that we saw it. */ - ellipsis_p = true; - } - else - ellipsis_p = false; - - /* Finish the parameter list. */ - if (parameters && ellipsis_p) - parameters->ellipsis_p = true; - - return parameters; -} - -/* Parse a parameter-declaration-list. - - parameter-declaration-list: - parameter-declaration - parameter-declaration-list , parameter-declaration - - Returns a representation of the parameter-declaration-list, as for - cp_parser_parameter_declaration_clause. However, the - `void_list_node' is never appended to the list. Upon return, - *IS_ERROR will be true iff an error occurred. */ - -static cp_parameter_declarator * -cp_parser_parameter_declaration_list (cp_parser* parser, bool *is_error) -{ - cp_parameter_declarator *parameters = NULL; - cp_parameter_declarator **tail = ¶meters; - bool saved_in_unbraced_linkage_specification_p; - - /* Assume all will go well. */ - *is_error = false; - /* The special considerations that apply to a function within an - unbraced linkage specifications do not apply to the parameters - to the function. */ - saved_in_unbraced_linkage_specification_p - = parser->in_unbraced_linkage_specification_p; - parser->in_unbraced_linkage_specification_p = false; - - /* Look for more parameters. */ - while (true) - { - cp_parameter_declarator *parameter; - bool parenthesized_p; - /* Parse the parameter. */ - parameter - = cp_parser_parameter_declaration (parser, - /*template_parm_p=*/false, - &parenthesized_p); - - /* If a parse error occurred parsing the parameter declaration, - then the entire parameter-declaration-list is erroneous. */ - if (!parameter) - { - *is_error = true; - parameters = NULL; - break; - } - /* Add the new parameter to the list. */ - *tail = parameter; - tail = ¶meter->next; - - /* Peek at the next token. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN) - || cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS) - /* These are for Objective-C++ */ - || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON) - || cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) - /* The parameter-declaration-list is complete. */ - break; - else if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) - { - cp_token *token; - - /* Peek at the next token. */ - token = cp_lexer_peek_nth_token (parser->lexer, 2); - /* If it's an ellipsis, then the list is complete. */ - if (token->type == CPP_ELLIPSIS) - break; - /* Otherwise, there must be more parameters. Consume the - `,'. */ - cp_lexer_consume_token (parser->lexer); - /* When parsing something like: - - int i(float f, double d) - - we can tell after seeing the declaration for "f" that we - are not looking at an initialization of a variable "i", - but rather at the declaration of a function "i". - - Due to the fact that the parsing of template arguments - (as specified to a template-id) requires backtracking we - cannot use this technique when inside a template argument - list. */ - if (!parser->in_template_argument_list_p - && !parser->in_type_id_in_expr_p - && cp_parser_uncommitted_to_tentative_parse_p (parser) - /* However, a parameter-declaration of the form - "foat(f)" (which is a valid declaration of a - parameter "f") can also be interpreted as an - expression (the conversion of "f" to "float"). */ - && !parenthesized_p) - cp_parser_commit_to_tentative_parse (parser); - } - else - { - cp_parser_error (parser, "expected %<,%> or %<...%>"); - if (!cp_parser_uncommitted_to_tentative_parse_p (parser)) - cp_parser_skip_to_closing_parenthesis (parser, - /*recovering=*/true, - /*or_comma=*/false, - /*consume_paren=*/false); - break; - } - } - - parser->in_unbraced_linkage_specification_p - = saved_in_unbraced_linkage_specification_p; - - return parameters; -} - -/* Parse a parameter declaration. - - parameter-declaration: - decl-specifier-seq declarator - decl-specifier-seq declarator = assignment-expression - decl-specifier-seq abstract-declarator [opt] - decl-specifier-seq abstract-declarator [opt] = assignment-expression - - If TEMPLATE_PARM_P is TRUE, then this parameter-declaration - declares a template parameter. (In that case, a non-nested `>' - token encountered during the parsing of the assignment-expression - is not interpreted as a greater-than operator.) - - Returns a representation of the parameter, or NULL if an error - occurs. If PARENTHESIZED_P is non-NULL, *PARENTHESIZED_P is set to - true iff the declarator is of the form "(p)". */ - -static cp_parameter_declarator * -cp_parser_parameter_declaration (cp_parser *parser, - bool template_parm_p, - bool *parenthesized_p) -{ - int declares_class_or_enum; - bool greater_than_is_operator_p; - cp_decl_specifier_seq decl_specifiers; - cp_declarator *declarator; - tree default_argument; - cp_token *token; - const char *saved_message; - - /* In a template parameter, `>' is not an operator. - - [temp.param] - - When parsing a default template-argument for a non-type - template-parameter, the first non-nested `>' is taken as the end - of the template parameter-list rather than a greater-than - operator. */ - greater_than_is_operator_p = !template_parm_p; - - /* Type definitions may not appear in parameter types. */ - saved_message = parser->type_definition_forbidden_message; - parser->type_definition_forbidden_message - = "types may not be defined in parameter types"; - - /* Parse the declaration-specifiers. */ - cp_parser_decl_specifier_seq (parser, - CP_PARSER_FLAGS_NONE, - &decl_specifiers, - &declares_class_or_enum); - /* If an error occurred, there's no reason to attempt to parse the - rest of the declaration. */ - if (cp_parser_error_occurred (parser)) - { - parser->type_definition_forbidden_message = saved_message; - return NULL; - } - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If the next token is a `)', `,', `=', `>', or `...', then there - is no declarator. */ - if (token->type == CPP_CLOSE_PAREN - || token->type == CPP_COMMA - || token->type == CPP_EQ - || token->type == CPP_ELLIPSIS - || token->type == CPP_GREATER) - { - declarator = NULL; - if (parenthesized_p) - *parenthesized_p = false; - } - /* Otherwise, there should be a declarator. */ - else - { - bool saved_default_arg_ok_p = parser->default_arg_ok_p; - parser->default_arg_ok_p = false; - - /* After seeing a decl-specifier-seq, if the next token is not a - "(", there is no possibility that the code is a valid - expression. Therefore, if parsing tentatively, we commit at - this point. */ - if (!parser->in_template_argument_list_p - /* In an expression context, having seen: - - (int((char ... - - we cannot be sure whether we are looking at a - function-type (taking a "char" as a parameter) or a cast - of some object of type "char" to "int". */ - && !parser->in_type_id_in_expr_p - && cp_parser_uncommitted_to_tentative_parse_p (parser) - && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)) - cp_parser_commit_to_tentative_parse (parser); - /* Parse the declarator. */ - declarator = cp_parser_declarator (parser, - CP_PARSER_DECLARATOR_EITHER, - /*ctor_dtor_or_conv_p=*/NULL, - parenthesized_p, - /*member_p=*/false); - parser->default_arg_ok_p = saved_default_arg_ok_p; - /* After the declarator, allow more attributes. */ - decl_specifiers.attributes - = chainon (decl_specifiers.attributes, - cp_parser_attributes_opt (parser)); - } - - /* The restriction on defining new types applies only to the type - of the parameter, not to the default argument. */ - parser->type_definition_forbidden_message = saved_message; - - /* If the next token is `=', then process a default argument. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)) - { - bool saved_greater_than_is_operator_p; - /* Consume the `='. */ - cp_lexer_consume_token (parser->lexer); - - /* If we are defining a class, then the tokens that make up the - default argument must be saved and processed later. */ - if (!template_parm_p && at_class_scope_p () - && TYPE_BEING_DEFINED (current_class_type)) - { - unsigned depth = 0; - cp_token *first_token; - cp_token *token; - - /* Add tokens until we have processed the entire default - argument. We add the range [first_token, token). */ - first_token = cp_lexer_peek_token (parser->lexer); - while (true) - { - bool done = false; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* What we do depends on what token we have. */ - switch (token->type) - { - /* In valid code, a default argument must be - immediately followed by a `,' `)', or `...'. */ - case CPP_COMMA: - case CPP_CLOSE_PAREN: - case CPP_ELLIPSIS: - /* If we run into a non-nested `;', `}', or `]', - then the code is invalid -- but the default - argument is certainly over. */ - case CPP_SEMICOLON: - case CPP_CLOSE_BRACE: - case CPP_CLOSE_SQUARE: - if (depth == 0) - done = true; - /* Update DEPTH, if necessary. */ - else if (token->type == CPP_CLOSE_PAREN - || token->type == CPP_CLOSE_BRACE - || token->type == CPP_CLOSE_SQUARE) - --depth; - break; - - case CPP_OPEN_PAREN: - case CPP_OPEN_SQUARE: - case CPP_OPEN_BRACE: - ++depth; - break; - - case CPP_GREATER: - /* If we see a non-nested `>', and `>' is not an - operator, then it marks the end of the default - argument. */ - if (!depth && !greater_than_is_operator_p) - done = true; - break; - - /* If we run out of tokens, issue an error message. */ - case CPP_EOF: - case CPP_PRAGMA_EOL: - error ("file ends in default argument"); - done = true; - break; - - case CPP_NAME: - case CPP_SCOPE: - /* In these cases, we should look for template-ids. - For example, if the default argument is - `X<int, double>()', we need to do name lookup to - figure out whether or not `X' is a template; if - so, the `,' does not end the default argument. - - That is not yet done. */ - break; - - default: - break; - } - - /* If we've reached the end, stop. */ - if (done) - break; - - /* Add the token to the token block. */ - token = cp_lexer_consume_token (parser->lexer); - } - - /* Create a DEFAULT_ARG to represented the unparsed default - argument. */ - default_argument = make_node (DEFAULT_ARG); - DEFARG_TOKENS (default_argument) - = cp_token_cache_new (first_token, token); - DEFARG_INSTANTIATIONS (default_argument) = NULL; - } - /* Outside of a class definition, we can just parse the - assignment-expression. */ - else - { - bool saved_local_variables_forbidden_p; - - /* Make sure that PARSER->GREATER_THAN_IS_OPERATOR_P is - set correctly. */ - saved_greater_than_is_operator_p - = parser->greater_than_is_operator_p; - parser->greater_than_is_operator_p = greater_than_is_operator_p; - /* Local variable names (and the `this' keyword) may not - appear in a default argument. */ - saved_local_variables_forbidden_p - = parser->local_variables_forbidden_p; - parser->local_variables_forbidden_p = true; - /* The default argument expression may cause implicitly - defined member functions to be synthesized, which will - result in garbage collection. We must treat this - situation as if we were within the body of function so as - to avoid collecting live data on the stack. */ - ++function_depth; - /* Parse the assignment-expression. */ - if (template_parm_p) - push_deferring_access_checks (dk_no_deferred); - default_argument - = cp_parser_assignment_expression (parser, /*cast_p=*/false); - if (template_parm_p) - pop_deferring_access_checks (); - /* Restore saved state. */ - --function_depth; - parser->greater_than_is_operator_p - = saved_greater_than_is_operator_p; - parser->local_variables_forbidden_p - = saved_local_variables_forbidden_p; - } - if (!parser->default_arg_ok_p) - { - if (!flag_pedantic_errors) - warning (0, "deprecated use of default argument for parameter of non-function"); - else - { - error ("default arguments are only permitted for function parameters"); - default_argument = NULL_TREE; - } - } - } - else - default_argument = NULL_TREE; - - return make_parameter_declarator (&decl_specifiers, - declarator, - default_argument); -} - -/* Parse a function-body. - - function-body: - compound_statement */ - -static void -cp_parser_function_body (cp_parser *parser) -{ - /* APPLE LOCAL radar 5982990 */ - cp_parser_compound_statement (parser, NULL, false, false); -} - -/* Parse a ctor-initializer-opt followed by a function-body. Return - true if a ctor-initializer was present. */ - -static bool -cp_parser_ctor_initializer_opt_and_function_body (cp_parser *parser) -{ - tree body; - bool ctor_initializer_p; - - /* Begin the function body. */ - body = begin_function_body (); - /* Parse the optional ctor-initializer. */ - ctor_initializer_p = cp_parser_ctor_initializer_opt (parser); - /* Parse the function-body. */ - cp_parser_function_body (parser); - /* Finish the function body. */ - finish_function_body (body); - - return ctor_initializer_p; -} - -/* Parse an initializer. - - initializer: - = initializer-clause - ( expression-list ) - - Returns an expression representing the initializer. If no - initializer is present, NULL_TREE is returned. - - *IS_PARENTHESIZED_INIT is set to TRUE if the `( expression-list )' - production is used, and zero otherwise. *IS_PARENTHESIZED_INIT is - set to FALSE if there is no initializer present. If there is an - initializer, and it is not a constant-expression, *NON_CONSTANT_P - is set to true; otherwise it is set to false. */ - -static tree -cp_parser_initializer (cp_parser* parser, bool* is_parenthesized_init, - bool* non_constant_p) -{ - cp_token *token; - tree init; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - - /* Let our caller know whether or not this initializer was - parenthesized. */ - *is_parenthesized_init = (token->type == CPP_OPEN_PAREN); - /* Assume that the initializer is constant. */ - *non_constant_p = false; - - if (token->type == CPP_EQ) - { - /* Consume the `='. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the initializer-clause. */ - init = cp_parser_initializer_clause (parser, non_constant_p); - } - else if (token->type == CPP_OPEN_PAREN) - init = cp_parser_parenthesized_expression_list (parser, false, - /*cast_p=*/false, - non_constant_p); - else - { - /* Anything else is an error. */ - cp_parser_error (parser, "expected initializer"); - init = error_mark_node; - } - - return init; -} - -/* Parse an initializer-clause. - - initializer-clause: - assignment-expression - { initializer-list , [opt] } - { } - - Returns an expression representing the initializer. - - If the `assignment-expression' production is used the value - returned is simply a representation for the expression. - - Otherwise, a CONSTRUCTOR is returned. The CONSTRUCTOR_ELTS will be - the elements of the initializer-list (or NULL, if the last - production is used). The TREE_TYPE for the CONSTRUCTOR will be - NULL_TREE. There is no way to detect whether or not the optional - trailing `,' was provided. NON_CONSTANT_P is as for - cp_parser_initializer. */ - -static tree -cp_parser_initializer_clause (cp_parser* parser, bool* non_constant_p) -{ - tree initializer; - - /* Assume the expression is constant. */ - *non_constant_p = false; - - /* If it is not a `{', then we are looking at an - assignment-expression. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)) - { - initializer - = cp_parser_constant_expression (parser, - /*allow_non_constant_p=*/true, - non_constant_p); - if (!*non_constant_p) - initializer = fold_non_dependent_expr (initializer); - } - else - { - /* Consume the `{' token. */ - cp_lexer_consume_token (parser->lexer); - /* Create a CONSTRUCTOR to represent the braced-initializer. */ - initializer = make_node (CONSTRUCTOR); - /* If it's not a `}', then there is a non-trivial initializer. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_BRACE)) - { - /* Parse the initializer list. */ - CONSTRUCTOR_ELTS (initializer) - = cp_parser_initializer_list (parser, non_constant_p); - /* A trailing `,' token is allowed. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) - cp_lexer_consume_token (parser->lexer); - } - /* Now, there should be a trailing `}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - } - - return initializer; -} - -/* Parse an initializer-list. - - initializer-list: - initializer-clause - initializer-list , initializer-clause - - GNU Extension: - - initializer-list: - identifier : initializer-clause - initializer-list, identifier : initializer-clause - - Returns a VEC of constructor_elt. The VALUE of each elt is an expression - for the initializer. If the INDEX of the elt is non-NULL, it is the - IDENTIFIER_NODE naming the field to initialize. NON_CONSTANT_P is - as for cp_parser_initializer. */ - -static VEC(constructor_elt,gc) * -cp_parser_initializer_list (cp_parser* parser, bool* non_constant_p) -{ - VEC(constructor_elt,gc) *v = NULL; - - /* Assume all of the expressions are constant. */ - *non_constant_p = false; - - /* Parse the rest of the list. */ - while (true) - { - cp_token *token; - tree identifier; - tree initializer; - bool clause_non_constant_p; - - /* If the next token is an identifier and the following one is a - colon, we are looking at the GNU designated-initializer - syntax. */ - if (cp_parser_allow_gnu_extensions_p (parser) - && cp_lexer_next_token_is (parser->lexer, CPP_NAME) - && cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_COLON) - { - /* Warn the user that they are using an extension. */ - if (pedantic) - pedwarn ("ISO C++ does not allow designated initializers"); - /* Consume the identifier. */ - identifier = cp_lexer_consume_token (parser->lexer)->u.value; - /* Consume the `:'. */ - cp_lexer_consume_token (parser->lexer); - } - else - identifier = NULL_TREE; - - /* Parse the initializer. */ - initializer = cp_parser_initializer_clause (parser, - &clause_non_constant_p); - /* If any clause is non-constant, so is the entire initializer. */ - if (clause_non_constant_p) - *non_constant_p = true; - - /* Add it to the vector. */ - CONSTRUCTOR_APPEND_ELT(v, identifier, initializer); - - /* If the next token is not a comma, we have reached the end of - the list. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) - break; - - /* Peek at the next token. */ - token = cp_lexer_peek_nth_token (parser->lexer, 2); - /* If the next token is a `}', then we're still done. An - initializer-clause can have a trailing `,' after the - initializer-list and before the closing `}'. */ - if (token->type == CPP_CLOSE_BRACE) - break; - - /* Consume the `,' token. */ - cp_lexer_consume_token (parser->lexer); - } - - return v; -} - -/* Classes [gram.class] */ - -/* Parse a class-name. - - class-name: - identifier - template-id - - TYPENAME_KEYWORD_P is true iff the `typename' keyword has been used - to indicate that names looked up in dependent types should be - assumed to be types. TEMPLATE_KEYWORD_P is true iff the `template' - keyword has been used to indicate that the name that appears next - is a template. TAG_TYPE indicates the explicit tag given before - the type name, if any. If CHECK_DEPENDENCY_P is FALSE, names are - looked up in dependent scopes. If CLASS_HEAD_P is TRUE, this class - is the class being defined in a class-head. - - Returns the TYPE_DECL representing the class. */ - -static tree -cp_parser_class_name (cp_parser *parser, - bool typename_keyword_p, - bool template_keyword_p, - enum tag_types tag_type, - bool check_dependency_p, - bool class_head_p, - bool is_declaration) -{ - tree decl; - tree scope; - bool typename_p; - cp_token *token; - - /* All class-names start with an identifier. */ - token = cp_lexer_peek_token (parser->lexer); - if (token->type != CPP_NAME && token->type != CPP_TEMPLATE_ID) - { - cp_parser_error (parser, "expected class-name"); - return error_mark_node; - } - - /* PARSER->SCOPE can be cleared when parsing the template-arguments - to a template-id, so we save it here. */ - scope = parser->scope; - if (scope == error_mark_node) - return error_mark_node; - - /* Any name names a type if we're following the `typename' keyword - in a qualified name where the enclosing scope is type-dependent. */ - typename_p = (typename_keyword_p && scope && TYPE_P (scope) - && dependent_type_p (scope)); - /* Handle the common case (an identifier, but not a template-id) - efficiently. */ - if (token->type == CPP_NAME - && !cp_parser_nth_token_starts_template_argument_list_p (parser, 2)) - { - cp_token *identifier_token; - tree identifier; - bool ambiguous_p; - - /* Look for the identifier. */ - identifier_token = cp_lexer_peek_token (parser->lexer); - ambiguous_p = identifier_token->ambiguous_p; - identifier = cp_parser_identifier (parser); - /* If the next token isn't an identifier, we are certainly not - looking at a class-name. */ - if (identifier == error_mark_node) - decl = error_mark_node; - /* If we know this is a type-name, there's no need to look it - up. */ - else if (typename_p) - decl = identifier; - 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 (ambiguous_p) - { - cp_parser_simulate_error (parser); - return error_mark_node; - } - /* If the next token is a `::', then the name must be a type - name. - - [basic.lookup.qual] - - During the lookup for a name preceding the :: scope - resolution operator, object, function, and enumerator - names are ignored. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)) - tag_type = typename_type; - /* Look up the name. */ - decl = cp_parser_lookup_name (parser, identifier, - tag_type, - /*is_template=*/false, - /*is_namespace=*/false, - check_dependency_p, - &ambiguous_decls); - if (ambiguous_decls) - { - error ("reference to %qD is ambiguous", identifier); - print_candidates (ambiguous_decls); - if (cp_parser_parsing_tentatively (parser)) - { - identifier_token->ambiguous_p = true; - cp_parser_simulate_error (parser); - } - return error_mark_node; - } - } - } - else - { - /* Try a template-id. */ - decl = cp_parser_template_id (parser, template_keyword_p, - check_dependency_p, - is_declaration); - if (decl == error_mark_node) - return error_mark_node; - } - - decl = cp_parser_maybe_treat_template_as_class (decl, class_head_p); - - /* If this is a typename, create a TYPENAME_TYPE. */ - if (typename_p && decl != error_mark_node) - { - decl = make_typename_type (scope, decl, typename_type, - /*complain=*/tf_error); - if (decl != error_mark_node) - decl = TYPE_NAME (decl); - } - - /* Check to see that it is really the name of a class. */ - if (TREE_CODE (decl) == TEMPLATE_ID_EXPR - && TREE_CODE (TREE_OPERAND (decl, 0)) == IDENTIFIER_NODE - && cp_lexer_next_token_is (parser->lexer, CPP_SCOPE)) - /* Situations like this: - - template <typename T> struct A { - typename T::template X<int>::I i; - }; - - are problematic. Is `T::template X<int>' a class-name? The - standard does not seem to be definitive, but there is no other - valid interpretation of the following `::'. Therefore, those - names are considered class-names. */ - { - decl = make_typename_type (scope, decl, tag_type, tf_error); - if (decl != error_mark_node) - decl = TYPE_NAME (decl); - } - else if (TREE_CODE (decl) != TYPE_DECL - || TREE_TYPE (decl) == error_mark_node - /* APPLE LOCAL begin radar 5277239 */ - || !IS_AGGR_TYPE (TREE_TYPE (decl)) - || cp_objc_property_reference_prefix (parser, TREE_TYPE (decl))) - /* APPLE LOCAL end radar 5277239 */ - decl = error_mark_node; - - if (decl == error_mark_node) - cp_parser_error (parser, "expected class-name"); - - return decl; -} - -/* Parse a class-specifier. - - class-specifier: - class-head { member-specification [opt] } - - Returns the TREE_TYPE representing the class. */ - -static tree -cp_parser_class_specifier (cp_parser* parser) -{ - cp_token *token; - tree type; - tree attributes = NULL_TREE; - int has_trailing_semicolon; - bool nested_name_specifier_p; - unsigned saved_num_template_parameter_lists; - bool saved_in_function_body; - tree old_scope = NULL_TREE; - tree scope = NULL_TREE; - tree bases; - - push_deferring_access_checks (dk_no_deferred); - - /* Parse the class-head. */ - type = cp_parser_class_head (parser, - &nested_name_specifier_p, - &attributes, - &bases); - /* If the class-head was a semantic disaster, skip the entire body - of the class. */ - if (!type) - { - cp_parser_skip_to_end_of_block_or_statement (parser); - pop_deferring_access_checks (); - return error_mark_node; - } - - /* Look for the `{'. */ - if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'")) - { - pop_deferring_access_checks (); - return error_mark_node; - } - - /* Process the base classes. If they're invalid, skip the - entire class body. */ - if (!xref_basetypes (type, bases)) - { - cp_parser_skip_to_closing_brace (parser); - - /* Consuming the closing brace yields better error messages - later on. */ - cp_lexer_consume_token (parser->lexer); - pop_deferring_access_checks (); - return error_mark_node; - } - - /* Issue an error message if type-definitions are forbidden here. */ - cp_parser_check_type_definition (parser); - /* Remember that we are defining one more class. */ - ++parser->num_classes_being_defined; - /* Inside the class, surrounding template-parameter-lists do not - apply. */ - saved_num_template_parameter_lists - = parser->num_template_parameter_lists; - parser->num_template_parameter_lists = 0; - /* We are not in a function body. */ - saved_in_function_body = parser->in_function_body; - parser->in_function_body = false; - - /* Start the class. */ - if (nested_name_specifier_p) - { - scope = CP_DECL_CONTEXT (TYPE_MAIN_DECL (type)); - old_scope = push_inner_scope (scope); - } - type = begin_class_definition (type, attributes); - - if (type == error_mark_node) - /* If the type is erroneous, skip the entire body of the class. */ - cp_parser_skip_to_closing_brace (parser); - else - /* Parse the member-specification. */ - cp_parser_member_specification_opt (parser); - - /* Look for the trailing `}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - /* We get better error messages by noticing a common problem: a - missing trailing `;'. */ - token = cp_lexer_peek_token (parser->lexer); - has_trailing_semicolon = (token->type == CPP_SEMICOLON); - /* Look for trailing attributes to apply to this class. */ - if (cp_parser_allow_gnu_extensions_p (parser)) - attributes = cp_parser_attributes_opt (parser); - if (type != error_mark_node) - type = finish_struct (type, attributes); - if (nested_name_specifier_p) - pop_inner_scope (old_scope, scope); - /* If this class is not itself within the scope of another class, - then we need to parse the bodies of all of the queued function - definitions. Note that the queued functions defined in a class - are not always processed immediately following the - class-specifier for that class. Consider: - - struct A { - struct B { void f() { sizeof (A); } }; - }; - - If `f' were processed before the processing of `A' were - completed, there would be no way to compute the size of `A'. - Note that the nesting we are interested in here is lexical -- - not the semantic nesting given by TYPE_CONTEXT. In particular, - for: - - struct A { struct B; }; - struct A::B { void f() { } }; - - there is no need to delay the parsing of `A::B::f'. */ - if (--parser->num_classes_being_defined == 0) - { - tree queue_entry; - tree fn; - tree class_type = NULL_TREE; - tree pushed_scope = NULL_TREE; - - /* In a first pass, parse default arguments to the functions. - Then, in a second pass, parse the bodies of the functions. - This two-phased approach handles cases like: - - struct S { - void f() { g(); } - void g(int i = 3); - }; - - */ - for (TREE_PURPOSE (parser->unparsed_functions_queues) - = nreverse (TREE_PURPOSE (parser->unparsed_functions_queues)); - (queue_entry = TREE_PURPOSE (parser->unparsed_functions_queues)); - TREE_PURPOSE (parser->unparsed_functions_queues) - = TREE_CHAIN (TREE_PURPOSE (parser->unparsed_functions_queues))) - { - fn = TREE_VALUE (queue_entry); - /* If there are default arguments that have not yet been processed, - take care of them now. */ - if (class_type != TREE_PURPOSE (queue_entry)) - { - if (pushed_scope) - pop_scope (pushed_scope); - class_type = TREE_PURPOSE (queue_entry); - pushed_scope = push_scope (class_type); - } - /* Make sure that any template parameters are in scope. */ - maybe_begin_member_template_processing (fn); - /* Parse the default argument expressions. */ - cp_parser_late_parsing_default_args (parser, fn); - /* Remove any template parameters from the symbol table. */ - maybe_end_member_template_processing (); - } - if (pushed_scope) - pop_scope (pushed_scope); - /* Now parse the body of the functions. */ - for (TREE_VALUE (parser->unparsed_functions_queues) - = nreverse (TREE_VALUE (parser->unparsed_functions_queues)); - (queue_entry = TREE_VALUE (parser->unparsed_functions_queues)); - TREE_VALUE (parser->unparsed_functions_queues) - = TREE_CHAIN (TREE_VALUE (parser->unparsed_functions_queues))) - { - /* Figure out which function we need to process. */ - fn = TREE_VALUE (queue_entry); - /* Parse the function. */ - cp_parser_late_parsing_for_member (parser, fn); - } - } - - /* Put back any saved access checks. */ - pop_deferring_access_checks (); - - /* Restore saved state. */ - parser->in_function_body = saved_in_function_body; - parser->num_template_parameter_lists - = saved_num_template_parameter_lists; - - return type; -} - -/* Parse a class-head. - - class-head: - class-key identifier [opt] base-clause [opt] - class-key nested-name-specifier identifier base-clause [opt] - class-key nested-name-specifier [opt] template-id - base-clause [opt] - - GNU Extensions: - class-key attributes identifier [opt] base-clause [opt] - class-key attributes nested-name-specifier identifier base-clause [opt] - class-key attributes nested-name-specifier [opt] template-id - base-clause [opt] - - Returns the TYPE of the indicated class. Sets - *NESTED_NAME_SPECIFIER_P to TRUE iff one of the productions - involving a nested-name-specifier was used, and FALSE otherwise. - - Returns error_mark_node if this is not a class-head. - - Returns NULL_TREE if the class-head is syntactically valid, but - semantically invalid in a way that means we should skip the entire - body of the class. */ - -static tree -cp_parser_class_head (cp_parser* parser, - bool* nested_name_specifier_p, - tree *attributes_p, - tree *bases) -{ - tree nested_name_specifier; - enum tag_types class_key; - tree id = NULL_TREE; - tree type = NULL_TREE; - tree attributes; - bool template_id_p = false; - bool qualified_p = false; - bool invalid_nested_name_p = false; - bool invalid_explicit_specialization_p = false; - tree pushed_scope = NULL_TREE; - unsigned num_templates; - - /* Assume no nested-name-specifier will be present. */ - *nested_name_specifier_p = false; - /* Assume no template parameter lists will be used in defining the - type. */ - num_templates = 0; - - /* Look for the class-key. */ - class_key = cp_parser_class_key (parser); - if (class_key == none_type) - return error_mark_node; - - /* Parse the attributes. */ - attributes = cp_parser_attributes_opt (parser); - - /* If the next token is `::', that is invalid -- but sometimes - people do try to write: - - struct ::S {}; - - Handle this gracefully by accepting the extra qualifier, and then - issuing an error about it later if this really is a - class-head. If it turns out just to be an elaborated type - specifier, remain silent. */ - if (cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false)) - qualified_p = true; - - push_deferring_access_checks (dk_no_check); - - /* Determine the name of the class. Begin by looking for an - optional nested-name-specifier. */ - nested_name_specifier - = cp_parser_nested_name_specifier_opt (parser, - /*typename_keyword_p=*/false, - /*check_dependency_p=*/false, - /*type_p=*/false, - /*is_declaration=*/false); - /* If there was a nested-name-specifier, then there *must* be an - identifier. */ - if (nested_name_specifier) - { - /* Although the grammar says `identifier', it really means - `class-name' or `template-name'. You are only allowed to - define a class that has already been declared with this - syntax. - - The proposed resolution for Core Issue 180 says that wherever - you see `class T::X' you should treat `X' as a type-name. - - It is OK to define an inaccessible class; for example: - - class A { class B; }; - class A::B {}; - - We do not know if we will see a class-name, or a - template-name. We look for a class-name first, in case the - class-name is a template-id; if we looked for the - template-name first we would stop after the template-name. */ - cp_parser_parse_tentatively (parser); - type = cp_parser_class_name (parser, - /*typename_keyword_p=*/false, - /*template_keyword_p=*/false, - class_type, - /*check_dependency_p=*/false, - /*class_head_p=*/true, - /*is_declaration=*/false); - /* If that didn't work, ignore the nested-name-specifier. */ - if (!cp_parser_parse_definitely (parser)) - { - invalid_nested_name_p = true; - id = cp_parser_identifier (parser); - if (id == error_mark_node) - id = NULL_TREE; - } - /* If we could not find a corresponding TYPE, treat this - declaration like an unqualified declaration. */ - if (type == error_mark_node) - nested_name_specifier = NULL_TREE; - /* Otherwise, count the number of templates used in TYPE and its - containing scopes. */ - else - { - tree scope; - - for (scope = TREE_TYPE (type); - scope && TREE_CODE (scope) != NAMESPACE_DECL; - scope = (TYPE_P (scope) - ? TYPE_CONTEXT (scope) - : DECL_CONTEXT (scope))) - if (TYPE_P (scope) - && CLASS_TYPE_P (scope) - && CLASSTYPE_TEMPLATE_INFO (scope) - && PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope)) - && !CLASSTYPE_TEMPLATE_SPECIALIZATION (scope)) - ++num_templates; - } - } - /* Otherwise, the identifier is optional. */ - else - { - /* We don't know whether what comes next is a template-id, - an identifier, or nothing at all. */ - cp_parser_parse_tentatively (parser); - /* Check for a template-id. */ - id = cp_parser_template_id (parser, - /*template_keyword_p=*/false, - /*check_dependency_p=*/true, - /*is_declaration=*/true); - /* If that didn't work, it could still be an identifier. */ - if (!cp_parser_parse_definitely (parser)) - { - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - id = cp_parser_identifier (parser); - else - id = NULL_TREE; - } - else - { - template_id_p = true; - ++num_templates; - } - } - - pop_deferring_access_checks (); - - if (id) - cp_parser_check_for_invalid_template_id (parser, id); - - /* If it's not a `:' or a `{' then we can't really be looking at a - class-head, since a class-head only appears as part of a - class-specifier. We have to detect this situation before calling - xref_tag, since that has irreversible side-effects. */ - if (!cp_parser_next_token_starts_class_definition_p (parser)) - { - cp_parser_error (parser, "expected %<{%> or %<:%>"); - return error_mark_node; - } - - /* At this point, we're going ahead with the class-specifier, even - if some other problem occurs. */ - cp_parser_commit_to_tentative_parse (parser); - /* Issue the error about the overly-qualified name now. */ - if (qualified_p) - cp_parser_error (parser, - "global qualification of class name is invalid"); - else if (invalid_nested_name_p) - cp_parser_error (parser, - "qualified name does not name a class"); - else if (nested_name_specifier) - { - tree scope; - - /* Reject typedef-names in class heads. */ - if (!DECL_IMPLICIT_TYPEDEF_P (type)) - { - error ("invalid class name in declaration of %qD", type); - type = NULL_TREE; - goto done; - } - - /* Figure out in what scope the declaration is being placed. */ - scope = current_scope (); - /* If that scope does not contain the scope in which the - class was originally declared, the program is invalid. */ - if (scope && !is_ancestor (scope, nested_name_specifier)) - { - error ("declaration of %qD in %qD which does not enclose %qD", - type, scope, nested_name_specifier); - type = NULL_TREE; - goto done; - } - /* [dcl.meaning] - - A declarator-id shall not be qualified exception of the - definition of a ... nested class outside of its class - ... [or] a the definition or explicit instantiation of a - class member of a namespace outside of its namespace. */ - if (scope == nested_name_specifier) - { - pedwarn ("extra qualification ignored"); - nested_name_specifier = NULL_TREE; - num_templates = 0; - } - } - /* An explicit-specialization must be preceded by "template <>". If - it is not, try to recover gracefully. */ - if (at_namespace_scope_p () - && parser->num_template_parameter_lists == 0 - && template_id_p) - { - error ("an explicit specialization must be preceded by %<template <>%>"); - invalid_explicit_specialization_p = true; - /* Take the same action that would have been taken by - cp_parser_explicit_specialization. */ - ++parser->num_template_parameter_lists; - begin_specialization (); - } - /* There must be no "return" statements between this point and the - end of this function; set "type "to the correct return value and - use "goto done;" to return. */ - /* Make sure that the right number of template parameters were - present. */ - if (!cp_parser_check_template_parameters (parser, num_templates)) - { - /* If something went wrong, there is no point in even trying to - process the class-definition. */ - type = NULL_TREE; - goto done; - } - - /* Look up the type. */ - if (template_id_p) - { - type = TREE_TYPE (id); - type = maybe_process_partial_specialization (type); - if (nested_name_specifier) - pushed_scope = push_scope (nested_name_specifier); - } - else if (nested_name_specifier) - { - tree class_type; - - /* Given: - - template <typename T> struct S { struct T }; - template <typename T> struct S<T>::T { }; - - we will get a TYPENAME_TYPE when processing the definition of - `S::T'. We need to resolve it to the actual type before we - try to define it. */ - if (TREE_CODE (TREE_TYPE (type)) == TYPENAME_TYPE) - { - class_type = resolve_typename_type (TREE_TYPE (type), - /*only_current_p=*/false); - if (class_type != error_mark_node) - type = TYPE_NAME (class_type); - else - { - cp_parser_error (parser, "could not resolve typename type"); - type = error_mark_node; - } - } - - maybe_process_partial_specialization (TREE_TYPE (type)); - class_type = current_class_type; - /* Enter the scope indicated by the nested-name-specifier. */ - pushed_scope = push_scope (nested_name_specifier); - /* Get the canonical version of this type. */ - type = TYPE_MAIN_DECL (TREE_TYPE (type)); - if (PROCESSING_REAL_TEMPLATE_DECL_P () - && !CLASSTYPE_TEMPLATE_SPECIALIZATION (TREE_TYPE (type))) - { - type = push_template_decl (type); - if (type == error_mark_node) - { - type = NULL_TREE; - goto done; - } - } - - type = TREE_TYPE (type); - *nested_name_specifier_p = true; - } - else /* The name is not a nested name. */ - { - /* If the class was unnamed, create a dummy name. */ - if (!id) - id = make_anon_name (); - type = xref_tag (class_key, id, /*tag_scope=*/ts_current, - parser->num_template_parameter_lists); - } - - /* Indicate whether this class was declared as a `class' or as a - `struct'. */ - if (TREE_CODE (type) == RECORD_TYPE) - CLASSTYPE_DECLARED_CLASS (type) = (class_key == class_type); - cp_parser_check_class_key (class_key, type); - - /* If this type was already complete, and we see another definition, - that's an error. */ - if (type != error_mark_node && COMPLETE_TYPE_P (type)) - { - error ("redefinition of %q#T", type); - error ("previous definition of %q+#T", type); - type = NULL_TREE; - goto done; - } - else if (type == error_mark_node) - type = NULL_TREE; - - /* We will have entered the scope containing the class; the names of - base classes should be looked up in that context. For example: - - struct A { struct B {}; struct C; }; - struct A::C : B {}; - - is valid. */ - *bases = NULL_TREE; - - /* Get the list of base-classes, if there is one. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COLON)) - *bases = cp_parser_base_clause (parser); - - done: - /* Leave the scope given by the nested-name-specifier. We will - enter the class scope itself while processing the members. */ - if (pushed_scope) - pop_scope (pushed_scope); - - if (invalid_explicit_specialization_p) - { - end_specialization (); - --parser->num_template_parameter_lists; - } - *attributes_p = attributes; - return type; -} - -/* Parse a class-key. - - class-key: - class - struct - union - - Returns the kind of class-key specified, or none_type to indicate - error. */ - -static enum tag_types -cp_parser_class_key (cp_parser* parser) -{ - cp_token *token; - enum tag_types tag_type; - - /* Look for the class-key. */ - token = cp_parser_require (parser, CPP_KEYWORD, "class-key"); - if (!token) - return none_type; - - /* Check to see if the TOKEN is a class-key. */ - tag_type = cp_parser_token_is_class_key (token); - if (!tag_type) - cp_parser_error (parser, "expected class-key"); - return tag_type; -} - -/* Parse an (optional) member-specification. - - member-specification: - member-declaration member-specification [opt] - access-specifier : member-specification [opt] */ - -static void -cp_parser_member_specification_opt (cp_parser* parser) -{ - while (true) - { - cp_token *token; - enum rid keyword; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's a `}', or EOF then we've seen all the members. */ - if (token->type == CPP_CLOSE_BRACE - || token->type == CPP_EOF - || token->type == CPP_PRAGMA_EOL) - break; - - /* See if this token is a keyword. */ - keyword = token->keyword; - switch (keyword) - { - case RID_PUBLIC: - case RID_PROTECTED: - case RID_PRIVATE: - /* Consume the access-specifier. */ - cp_lexer_consume_token (parser->lexer); - /* Remember which access-specifier is active. */ - current_access_specifier = token->u.value; - /* Look for the `:'. */ - cp_parser_require (parser, CPP_COLON, "`:'"); - break; - - default: - /* Accept #pragmas at class scope. */ - if (token->type == CPP_PRAGMA) - { - cp_parser_pragma (parser, pragma_external); - break; - } - - /* Otherwise, the next construction must be a - member-declaration. */ - cp_parser_member_declaration (parser); - } - } -} - -/* Parse a member-declaration. - - member-declaration: - decl-specifier-seq [opt] member-declarator-list [opt] ; - function-definition ; [opt] - :: [opt] nested-name-specifier template [opt] unqualified-id ; - using-declaration - template-declaration - - member-declarator-list: - member-declarator - member-declarator-list , member-declarator - - member-declarator: - declarator pure-specifier [opt] - declarator constant-initializer [opt] - identifier [opt] : constant-expression - - GNU Extensions: - - member-declaration: - __extension__ member-declaration - - member-declarator: - declarator attributes [opt] pure-specifier [opt] - declarator attributes [opt] constant-initializer [opt] - identifier [opt] attributes [opt] : constant-expression */ - -static void -cp_parser_member_declaration (cp_parser* parser) -{ - cp_decl_specifier_seq decl_specifiers; - tree prefix_attributes; - tree decl; - int declares_class_or_enum; - bool friend_p; - cp_token *token; - int saved_pedantic; - - /* Check for the `__extension__' keyword. */ - if (cp_parser_extension_opt (parser, &saved_pedantic)) - { - /* Recurse. */ - cp_parser_member_declaration (parser); - /* Restore the old value of the PEDANTIC flag. */ - pedantic = saved_pedantic; - - return; - } - - /* Check for a template-declaration. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE)) - { - /* An explicit specialization here is an error condition, and we - expect the specialization handler to detect and report this. */ - if (cp_lexer_peek_nth_token (parser->lexer, 2)->type == CPP_LESS - && cp_lexer_peek_nth_token (parser->lexer, 3)->type == CPP_GREATER) - cp_parser_explicit_specialization (parser); - else - cp_parser_template_declaration (parser, /*member_p=*/true); - - return; - } - - /* Check for a using-declaration. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_USING)) - { - /* Parse the using-declaration. */ - cp_parser_using_declaration (parser, - /*access_declaration_p=*/false); - return; - } - - /* Check for @defs. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_DEFS)) - { - tree ivar, member; - tree ivar_chains = cp_parser_objc_defs_expression (parser); - ivar = ivar_chains; - while (ivar) - { - member = ivar; - ivar = TREE_CHAIN (member); - TREE_CHAIN (member) = NULL_TREE; - finish_member_declaration (member); - } - /* APPLE LOCAL begin C* warnings to easy porting to new abi */ - if (flag_objc_abi == 3 - || (flag_objc2_check && flag_objc_abi == 1)) - warning (0, "@defs will not be supported in future"); - /* APPLE LOCAL radar 4705250 */ - else if (flag_objc_abi == 2 && flag_objc_atdefs != 1) - error ("@defs will not be supported in future"); - /* APPLE LOCAL end C* warnings to easy porting to new abi */ - return; - } - - if (cp_parser_using_declaration (parser, /*access_declaration=*/true)) - return; - - /* Parse the decl-specifier-seq. */ - cp_parser_decl_specifier_seq (parser, - CP_PARSER_FLAGS_OPTIONAL, - &decl_specifiers, - &declares_class_or_enum); - prefix_attributes = decl_specifiers.attributes; - decl_specifiers.attributes = NULL_TREE; - /* Check for an invalid type-name. */ - if (!decl_specifiers.type - && cp_parser_parse_and_diagnose_invalid_type_name (parser)) - return; - /* If there is no declarator, then the decl-specifier-seq should - specify a type. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) - { - /* If there was no decl-specifier-seq, and the next token is a - `;', then we have something like: - - struct S { ; }; - - [class.mem] - - Each member-declaration shall declare at least one member - name of the class. */ - if (!decl_specifiers.any_specifiers_p) - { - cp_token *token = cp_lexer_peek_token (parser->lexer); - if (pedantic && !token->in_system_header) - pedwarn ("%Hextra %<;%>", &token->location); - } - else - { - tree type; - - /* See if this declaration is a friend. */ - friend_p = cp_parser_friend_p (&decl_specifiers); - /* If there were decl-specifiers, check to see if there was - a class-declaration. */ - type = check_tag_decl (&decl_specifiers); - /* Nested classes have already been added to the class, but - a `friend' needs to be explicitly registered. */ - if (friend_p) - { - /* If the `friend' keyword was present, the friend must - be introduced with a class-key. */ - if (!declares_class_or_enum) - error ("a class-key must be used when declaring a friend"); - /* In this case: - - template <typename T> struct A { - friend struct A<T>::B; - }; - - A<T>::B will be represented by a TYPENAME_TYPE, and - therefore not recognized by check_tag_decl. */ - if (!type - && decl_specifiers.type - && TYPE_P (decl_specifiers.type)) - type = decl_specifiers.type; - if (!type || !TYPE_P (type)) - error ("friend declaration does not name a class or " - "function"); - else - make_friend_class (current_class_type, type, - /*complain=*/true); - } - /* If there is no TYPE, an error message will already have - been issued. */ - else if (!type || type == error_mark_node) - ; - /* An anonymous aggregate has to be handled specially; such - a declaration really declares a data member (with a - particular type), as opposed to a nested class. */ - else if (ANON_AGGR_TYPE_P (type)) - { - /* Remove constructors and such from TYPE, now that we - know it is an anonymous aggregate. */ - fixup_anonymous_aggr (type); - /* And make the corresponding data member. */ - decl = build_decl (FIELD_DECL, NULL_TREE, type); - /* Add it to the class. */ - finish_member_declaration (decl); - } - else - cp_parser_check_access_in_redeclaration (TYPE_NAME (type)); - } - } - else - { - /* See if these declarations will be friends. */ - friend_p = cp_parser_friend_p (&decl_specifiers); - - /* Keep going until we hit the `;' at the end of the - declaration. */ - while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - { - tree attributes = NULL_TREE; - tree first_attribute; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - - /* Check for a bitfield declaration. */ - if (token->type == CPP_COLON - || (token->type == CPP_NAME - && cp_lexer_peek_nth_token (parser->lexer, 2)->type - == CPP_COLON)) - { - tree identifier; - tree width; - - /* Get the name of the bitfield. Note that we cannot just - check TOKEN here because it may have been invalidated by - the call to cp_lexer_peek_nth_token above. */ - if (cp_lexer_peek_token (parser->lexer)->type != CPP_COLON) - identifier = cp_parser_identifier (parser); - else - identifier = NULL_TREE; - - /* Consume the `:' token. */ - cp_lexer_consume_token (parser->lexer); - /* Get the width of the bitfield. */ - width - = cp_parser_constant_expression (parser, - /*allow_non_constant=*/false, - NULL); - - /* Look for attributes that apply to the bitfield. */ - attributes = cp_parser_attributes_opt (parser); - /* Remember which attributes are prefix attributes and - which are not. */ - first_attribute = attributes; - /* Combine the attributes. */ - attributes = chainon (prefix_attributes, attributes); - - /* Create the bitfield declaration. */ - decl = grokbitfield (identifier - ? make_id_declarator (NULL_TREE, - identifier, - sfk_none) - : NULL, - &decl_specifiers, - width); - /* Apply the attributes. */ - cplus_decl_attributes (&decl, attributes, /*flags=*/0); - } - else - { - cp_declarator *declarator; - tree initializer; - tree asm_specification; - int ctor_dtor_or_conv_p; - - /* Parse the declarator. */ - declarator - = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED, - &ctor_dtor_or_conv_p, - /*parenthesized_p=*/NULL, - /*member_p=*/true); - - /* If something went wrong parsing the declarator, make sure - that we at least consume some tokens. */ - if (declarator == cp_error_declarator) - { - /* Skip to the end of the statement. */ - cp_parser_skip_to_end_of_statement (parser); - /* If the next token is not a semicolon, that is - probably because we just skipped over the body of - a function. So, we consume a semicolon if - present, but do not issue an error message if it - is not present. */ - if (cp_lexer_next_token_is (parser->lexer, - CPP_SEMICOLON)) - cp_lexer_consume_token (parser->lexer); - return; - } - - if (declares_class_or_enum & 2) - cp_parser_check_for_definition_in_return_type - (declarator, decl_specifiers.type); - - /* Look for an asm-specification. */ - asm_specification = cp_parser_asm_specification_opt (parser); - /* Look for attributes that apply to the declaration. */ - attributes = cp_parser_attributes_opt (parser); - /* Remember which attributes are prefix attributes and - which are not. */ - first_attribute = attributes; - /* Combine the attributes. */ - attributes = chainon (prefix_attributes, attributes); - - /* If it's an `=', then we have a constant-initializer or a - pure-specifier. It is not correct to parse the - initializer before registering the member declaration - since the member declaration should be in scope while - its initializer is processed. However, the rest of the - front end does not yet provide an interface that allows - us to handle this correctly. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_EQ)) - { - /* In [class.mem]: - - A pure-specifier shall be used only in the declaration of - a virtual function. - - A member-declarator can contain a constant-initializer - only if it declares a static member of integral or - enumeration type. - - Therefore, if the DECLARATOR is for a function, we look - for a pure-specifier; otherwise, we look for a - constant-initializer. When we call `grokfield', it will - perform more stringent semantics checks. */ - if (function_declarator_p (declarator)) - initializer = cp_parser_pure_specifier (parser); - else - /* Parse the initializer. */ - initializer = cp_parser_constant_initializer (parser); - } - /* Otherwise, there is no initializer. */ - else - initializer = NULL_TREE; - - /* See if we are probably looking at a function - definition. We are certainly not looking at a - member-declarator. Calling `grokfield' has - side-effects, so we must not do it unless we are sure - that we are looking at a member-declarator. */ - if (cp_parser_token_starts_function_definition_p - (cp_lexer_peek_token (parser->lexer))) - { - /* The grammar does not allow a pure-specifier to be - used when a member function is defined. (It is - possible that this fact is an oversight in the - standard, since a pure function may be defined - outside of the class-specifier. */ - if (initializer) - error ("pure-specifier on function-definition"); - decl = cp_parser_save_member_function_body (parser, - &decl_specifiers, - declarator, - attributes); - /* If the member was not a friend, declare it here. */ - if (!friend_p) - finish_member_declaration (decl); - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If the next token is a semicolon, consume it. */ - if (token->type == CPP_SEMICOLON) - cp_lexer_consume_token (parser->lexer); - return; - } - else - /* Create the declaration. */ - decl = grokfield (declarator, &decl_specifiers, - initializer, /*init_const_expr_p=*/true, - asm_specification, - attributes); - } - - /* Reset PREFIX_ATTRIBUTES. */ - while (attributes && TREE_CHAIN (attributes) != first_attribute) - attributes = TREE_CHAIN (attributes); - if (attributes) - TREE_CHAIN (attributes) = NULL_TREE; - - /* If there is any qualification still in effect, clear it - now; we will be starting fresh with the next declarator. */ - parser->scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - /* If it's a `,', then there are more declarators. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) - cp_lexer_consume_token (parser->lexer); - /* If the next token isn't a `;', then we have a parse error. */ - else if (cp_lexer_next_token_is_not (parser->lexer, - CPP_SEMICOLON)) - { - cp_parser_error (parser, "expected %<;%>"); - /* Skip tokens until we find a `;'. */ - cp_parser_skip_to_end_of_statement (parser); - - break; - } - - if (decl) - { - /* Add DECL to the list of members. */ - if (!friend_p) - finish_member_declaration (decl); - - if (TREE_CODE (decl) == FUNCTION_DECL) - cp_parser_save_default_args (parser, decl); - } - } - } - - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); -} - -/* Parse a pure-specifier. - - pure-specifier: - = 0 - - Returns INTEGER_ZERO_NODE if a pure specifier is found. - Otherwise, ERROR_MARK_NODE is returned. */ - -static tree -cp_parser_pure_specifier (cp_parser* parser) -{ - cp_token *token; - - /* Look for the `=' token. */ - if (!cp_parser_require (parser, CPP_EQ, "`='")) - return error_mark_node; - /* Look for the `0' token. */ - token = cp_lexer_consume_token (parser->lexer); - /* c_lex_with_flags marks a single digit '0' with PURE_ZERO. */ - if (token->type != CPP_NUMBER || !(token->flags & PURE_ZERO)) - { - cp_parser_error (parser, - "invalid pure specifier (only `= 0' is allowed)"); - cp_parser_skip_to_end_of_statement (parser); - return error_mark_node; - } - if (PROCESSING_REAL_TEMPLATE_DECL_P ()) - { - error ("templates may not be %<virtual%>"); - return error_mark_node; - } - - return integer_zero_node; -} - -/* Parse a constant-initializer. - - constant-initializer: - = constant-expression - - Returns a representation of the constant-expression. */ - -static tree -cp_parser_constant_initializer (cp_parser* parser) -{ - /* Look for the `=' token. */ - if (!cp_parser_require (parser, CPP_EQ, "`='")) - return error_mark_node; - - /* It is invalid to write: - - struct S { static const int i = { 7 }; }; - - */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_BRACE)) - { - cp_parser_error (parser, - "a brace-enclosed initializer is not allowed here"); - /* Consume the opening brace. */ - cp_lexer_consume_token (parser->lexer); - /* Skip the initializer. */ - cp_parser_skip_to_closing_brace (parser); - /* Look for the trailing `}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - - return error_mark_node; - } - - return cp_parser_constant_expression (parser, - /*allow_non_constant=*/false, - NULL); -} - -/* Derived classes [gram.class.derived] */ - -/* Parse a base-clause. - - base-clause: - : base-specifier-list - - base-specifier-list: - base-specifier - base-specifier-list , base-specifier - - Returns a TREE_LIST representing the base-classes, in the order in - which they were declared. The representation of each node is as - described by cp_parser_base_specifier. - - In the case that no bases are specified, this function will return - NULL_TREE, not ERROR_MARK_NODE. */ - -static tree -cp_parser_base_clause (cp_parser* parser) -{ - tree bases = NULL_TREE; - - /* Look for the `:' that begins the list. */ - cp_parser_require (parser, CPP_COLON, "`:'"); - - /* Scan the base-specifier-list. */ - while (true) - { - cp_token *token; - tree base; - - /* Look for the base-specifier. */ - base = cp_parser_base_specifier (parser); - /* Add BASE to the front of the list. */ - if (base != error_mark_node) - { - TREE_CHAIN (base) = bases; - bases = base; - } - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's not a comma, then the list is complete. */ - if (token->type != CPP_COMMA) - break; - /* Consume the `,'. */ - cp_lexer_consume_token (parser->lexer); - } - - /* PARSER->SCOPE may still be non-NULL at this point, if the last - base class had a qualified name. However, the next name that - appears is certainly not qualified. */ - parser->scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - - return nreverse (bases); -} - -/* Parse a base-specifier. - - base-specifier: - :: [opt] nested-name-specifier [opt] class-name - virtual access-specifier [opt] :: [opt] nested-name-specifier - [opt] class-name - access-specifier virtual [opt] :: [opt] nested-name-specifier - [opt] class-name - - Returns a TREE_LIST. The TREE_PURPOSE will be one of - ACCESS_{DEFAULT,PUBLIC,PROTECTED,PRIVATE}_[VIRTUAL]_NODE to - indicate the specifiers provided. The TREE_VALUE will be a TYPE - (or the ERROR_MARK_NODE) indicating the type that was specified. */ - -static tree -cp_parser_base_specifier (cp_parser* parser) -{ - cp_token *token; - bool done = false; - bool virtual_p = false; - bool duplicate_virtual_error_issued_p = false; - bool duplicate_access_error_issued_p = false; - bool class_scope_p, template_p; - tree access = access_default_node; - tree type; - - /* Process the optional `virtual' and `access-specifier'. */ - while (!done) - { - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Process `virtual'. */ - switch (token->keyword) - { - case RID_VIRTUAL: - /* If `virtual' appears more than once, issue an error. */ - if (virtual_p && !duplicate_virtual_error_issued_p) - { - cp_parser_error (parser, - "%<virtual%> specified more than once in base-specified"); - duplicate_virtual_error_issued_p = true; - } - - virtual_p = true; - - /* Consume the `virtual' token. */ - cp_lexer_consume_token (parser->lexer); - - break; - - case RID_PUBLIC: - case RID_PROTECTED: - case RID_PRIVATE: - /* If more than one access specifier appears, issue an - error. */ - if (access != access_default_node - && !duplicate_access_error_issued_p) - { - cp_parser_error (parser, - "more than one access specifier in base-specified"); - duplicate_access_error_issued_p = true; - } - - access = ridpointers[(int) token->keyword]; - - /* Consume the access-specifier. */ - cp_lexer_consume_token (parser->lexer); - - break; - - default: - done = true; - break; - } - } - /* It is not uncommon to see programs mechanically, erroneously, use - the 'typename' keyword to denote (dependent) qualified types - as base classes. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TYPENAME)) - { - if (!processing_template_decl) - error ("keyword %<typename%> not allowed outside of templates"); - else - error ("keyword %<typename%> not allowed in this context " - "(the base class is implicitly a type)"); - cp_lexer_consume_token (parser->lexer); - } - - /* Look for the optional `::' operator. */ - cp_parser_global_scope_opt (parser, /*current_scope_valid_p=*/false); - /* Look for the nested-name-specifier. The simplest way to - implement: - - [temp.res] - - The keyword `typename' is not permitted in a base-specifier or - mem-initializer; in these contexts a qualified name that - depends on a template-parameter is implicitly assumed to be a - type name. - - is to pretend that we have seen the `typename' keyword at this - point. */ - cp_parser_nested_name_specifier_opt (parser, - /*typename_keyword_p=*/true, - /*check_dependency_p=*/true, - typename_type, - /*is_declaration=*/true); - /* If the base class is given by a qualified name, assume that names - we see are type names or templates, as appropriate. */ - class_scope_p = (parser->scope && TYPE_P (parser->scope)); - template_p = class_scope_p && cp_parser_optional_template_keyword (parser); - - /* Finally, look for the class-name. */ - type = cp_parser_class_name (parser, - class_scope_p, - template_p, - typename_type, - /*check_dependency_p=*/true, - /*class_head_p=*/false, - /*is_declaration=*/true); - - if (type == error_mark_node) - return error_mark_node; - - return finish_base_specifier (TREE_TYPE (type), access, virtual_p); -} - -/* Exception handling [gram.exception] */ - -/* Parse an (optional) exception-specification. - - exception-specification: - throw ( type-id-list [opt] ) - - Returns a TREE_LIST representing the exception-specification. The - TREE_VALUE of each node is a type. */ - -static tree -cp_parser_exception_specification_opt (cp_parser* parser) -{ - cp_token *token; - tree type_id_list; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's not `throw', then there's no exception-specification. */ - if (!cp_parser_is_keyword (token, RID_THROW)) - return NULL_TREE; - - /* Consume the `throw'. */ - cp_lexer_consume_token (parser->lexer); - - /* Look for the `('. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's not a `)', then there is a type-id-list. */ - if (token->type != CPP_CLOSE_PAREN) - { - const char *saved_message; - - /* Types may not be defined in an exception-specification. */ - saved_message = parser->type_definition_forbidden_message; - parser->type_definition_forbidden_message - = "types may not be defined in an exception-specification"; - /* Parse the type-id-list. */ - type_id_list = cp_parser_type_id_list (parser); - /* Restore the saved message. */ - parser->type_definition_forbidden_message = saved_message; - } - else - type_id_list = empty_except_spec; - - /* Look for the `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - return type_id_list; -} - -/* Parse an (optional) type-id-list. - - type-id-list: - type-id - type-id-list , type-id - - Returns a TREE_LIST. The TREE_VALUE of each node is a TYPE, - in the order that the types were presented. */ - -static tree -cp_parser_type_id_list (cp_parser* parser) -{ - tree types = NULL_TREE; - - while (true) - { - cp_token *token; - tree type; - - /* Get the next type-id. */ - type = cp_parser_type_id (parser); - /* Add it to the list. */ - types = add_exception_specifier (types, type, /*complain=*/1); - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it is not a `,', we are done. */ - if (token->type != CPP_COMMA) - break; - /* Consume the `,'. */ - cp_lexer_consume_token (parser->lexer); - } - - return nreverse (types); -} - -/* Parse a try-block. - - try-block: - try compound-statement handler-seq */ - -static tree -cp_parser_try_block (cp_parser* parser) -{ - tree try_block; - - cp_parser_require_keyword (parser, RID_TRY, "`try'"); - try_block = begin_try_block (); - /* APPLE LOCAL radar 5982990 */ - cp_parser_compound_statement (parser, NULL, true, false); - finish_try_block (try_block); - cp_parser_handler_seq (parser); - finish_handler_sequence (try_block); - - return try_block; -} - -/* Parse a function-try-block. - - function-try-block: - try ctor-initializer [opt] function-body handler-seq */ - -static bool -cp_parser_function_try_block (cp_parser* parser) -{ - tree compound_stmt; - tree try_block; - bool ctor_initializer_p; - - /* Look for the `try' keyword. */ - if (!cp_parser_require_keyword (parser, RID_TRY, "`try'")) - return false; - /* Let the rest of the front-end know where we are. */ - try_block = begin_function_try_block (&compound_stmt); - /* Parse the function-body. */ - ctor_initializer_p - = cp_parser_ctor_initializer_opt_and_function_body (parser); - /* We're done with the `try' part. */ - finish_function_try_block (try_block); - /* Parse the handlers. */ - cp_parser_handler_seq (parser); - /* We're done with the handlers. */ - finish_function_handler_sequence (try_block, compound_stmt); - - return ctor_initializer_p; -} - -/* Parse a handler-seq. - - handler-seq: - handler handler-seq [opt] */ - -static void -cp_parser_handler_seq (cp_parser* parser) -{ - while (true) - { - cp_token *token; - - /* Parse the handler. */ - cp_parser_handler (parser); - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's not `catch' then there are no more handlers. */ - if (!cp_parser_is_keyword (token, RID_CATCH)) - break; - } -} - -/* Parse a handler. - - handler: - catch ( exception-declaration ) compound-statement */ - -static void -cp_parser_handler (cp_parser* parser) -{ - tree handler; - tree declaration; - - cp_parser_require_keyword (parser, RID_CATCH, "`catch'"); - handler = begin_handler (); - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - declaration = cp_parser_exception_declaration (parser); - finish_handler_parms (declaration, handler); - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - /* APPLE LOCAL radar 5982990 */ - cp_parser_compound_statement (parser, NULL, false, false); - finish_handler (handler); -} - -/* Parse an exception-declaration. - - exception-declaration: - type-specifier-seq declarator - type-specifier-seq abstract-declarator - type-specifier-seq - ... - - Returns a VAR_DECL for the declaration, or NULL_TREE if the - ellipsis variant is used. */ - -static tree -cp_parser_exception_declaration (cp_parser* parser) -{ - cp_decl_specifier_seq type_specifiers; - cp_declarator *declarator; - const char *saved_message; - - /* If it's an ellipsis, it's easy to handle. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_ELLIPSIS)) - { - /* Consume the `...' token. */ - cp_lexer_consume_token (parser->lexer); - return NULL_TREE; - } - - /* Types may not be defined in exception-declarations. */ - saved_message = parser->type_definition_forbidden_message; - parser->type_definition_forbidden_message - = "types may not be defined in exception-declarations"; - - /* Parse the type-specifier-seq. */ - cp_parser_type_specifier_seq (parser, /*is_condition=*/false, - &type_specifiers); - /* If it's a `)', then there is no declarator. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_PAREN)) - declarator = NULL; - else - declarator = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_EITHER, - /*ctor_dtor_or_conv_p=*/NULL, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - - /* Restore the saved message. */ - parser->type_definition_forbidden_message = saved_message; - - if (!type_specifiers.any_specifiers_p) - return error_mark_node; - - return grokdeclarator (declarator, &type_specifiers, CATCHPARM, 1, NULL); -} - -/* Parse a throw-expression. - - throw-expression: - throw assignment-expression [opt] - - Returns a THROW_EXPR representing the throw-expression. */ - -static tree -cp_parser_throw_expression (cp_parser* parser) -{ - tree expression; - cp_token* token; - - cp_parser_require_keyword (parser, RID_THROW, "`throw'"); - token = cp_lexer_peek_token (parser->lexer); - /* Figure out whether or not there is an assignment-expression - following the "throw" keyword. */ - if (token->type == CPP_COMMA - || token->type == CPP_SEMICOLON - || token->type == CPP_CLOSE_PAREN - || token->type == CPP_CLOSE_SQUARE - || token->type == CPP_CLOSE_BRACE - || token->type == CPP_COLON) - expression = NULL_TREE; - else - expression = cp_parser_assignment_expression (parser, - /*cast_p=*/false); - - return build_throw (expression); -} - -/* GNU Extensions */ - -/* Parse an (optional) asm-specification. - - asm-specification: - asm ( string-literal ) - - If the asm-specification is present, returns a STRING_CST - corresponding to the string-literal. Otherwise, returns - NULL_TREE. */ - -static tree -cp_parser_asm_specification_opt (cp_parser* parser) -{ - cp_token *token; - tree asm_specification; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If the next token isn't the `asm' keyword, then there's no - asm-specification. */ - if (!cp_parser_is_keyword (token, RID_ASM)) - return NULL_TREE; - - /* Consume the `asm' token. */ - cp_lexer_consume_token (parser->lexer); - /* Look for the `('. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - - /* Look for the string-literal. */ - asm_specification = cp_parser_string_literal (parser, false, false); - - /* Look for the `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`('"); - - return asm_specification; -} - -/* Parse an asm-operand-list. - - asm-operand-list: - asm-operand - asm-operand-list , asm-operand - - asm-operand: - string-literal ( expression ) - [ string-literal ] string-literal ( expression ) - - Returns a TREE_LIST representing the operands. The TREE_VALUE of - each node is the expression. The TREE_PURPOSE is itself a - TREE_LIST whose TREE_PURPOSE is a STRING_CST for the bracketed - string-literal (or NULL_TREE if not present) and whose TREE_VALUE - is a STRING_CST for the string literal before the parenthesis. */ - -static tree -cp_parser_asm_operand_list (cp_parser* parser) -{ - tree asm_operands = NULL_TREE; - - while (true) - { - tree string_literal; - tree expression; - tree name; - - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_SQUARE)) - { - /* Consume the `[' token. */ - cp_lexer_consume_token (parser->lexer); - /* Read the operand name. */ - name = cp_parser_identifier (parser); - if (name != error_mark_node) - name = build_string (IDENTIFIER_LENGTH (name), - IDENTIFIER_POINTER (name)); - /* Look for the closing `]'. */ - cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"); - } - else - name = NULL_TREE; - /* Look for the string-literal. */ - string_literal = cp_parser_string_literal (parser, false, false); - - /* Look for the `('. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - /* Parse the expression. */ - expression = cp_parser_expression (parser, /*cast_p=*/false); - /* Look for the `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - /* Add this operand to the list. */ - asm_operands = tree_cons (build_tree_list (name, string_literal), - expression, - asm_operands); - /* If the next token is not a `,', there are no more - operands. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) - break; - /* Consume the `,'. */ - cp_lexer_consume_token (parser->lexer); - } - - return nreverse (asm_operands); -} - -/* Parse an asm-clobber-list. - - asm-clobber-list: - string-literal - asm-clobber-list , string-literal - - Returns a TREE_LIST, indicating the clobbers in the order that they - appeared. The TREE_VALUE of each node is a STRING_CST. */ - -static tree -cp_parser_asm_clobber_list (cp_parser* parser) -{ - tree clobbers = NULL_TREE; - - while (true) - { - tree string_literal; - - /* Look for the string literal. */ - string_literal = cp_parser_string_literal (parser, false, false); - /* Add it to the list. */ - clobbers = tree_cons (NULL_TREE, string_literal, clobbers); - /* If the next token is not a `,', then the list is - complete. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) - break; - /* Consume the `,' token. */ - cp_lexer_consume_token (parser->lexer); - } - - return clobbers; -} - -/* Parse an (optional) series of attributes. - - attributes: - attributes attribute - - attribute: - __attribute__ (( attribute-list [opt] )) - - The return value is as for cp_parser_attribute_list. */ - -static tree -cp_parser_attributes_opt (cp_parser* parser) -{ - tree attributes = NULL_TREE; - - while (true) - { - cp_token *token; - tree attribute_list; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's not `__attribute__', then we're done. */ - if (token->keyword != RID_ATTRIBUTE) - break; - - /* Consume the `__attribute__' keyword. */ - cp_lexer_consume_token (parser->lexer); - /* Look for the two `(' tokens. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - if (token->type != CPP_CLOSE_PAREN) - /* Parse the attribute-list. */ - attribute_list = cp_parser_attribute_list (parser); - else - /* If the next token is a `)', then there is no attribute - list. */ - attribute_list = NULL; - - /* Look for the two `)' tokens. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - /* Add these new attributes to the list. */ - attributes = chainon (attributes, attribute_list); - } - - return attributes; -} - -/* Parse an attribute-list. - - attribute-list: - attribute - attribute-list , attribute - - attribute: - identifier - identifier ( identifier ) - identifier ( identifier , expression-list ) - identifier ( expression-list ) - - Returns a TREE_LIST, or NULL_TREE on error. Each node corresponds - to an attribute. The TREE_PURPOSE of each node is the identifier - indicating which attribute is in use. The TREE_VALUE represents - the arguments, if any. */ - -static tree -cp_parser_attribute_list (cp_parser* parser) -{ - tree attribute_list = NULL_TREE; - bool save_translate_strings_p = parser->translate_strings_p; - - parser->translate_strings_p = false; - while (true) - { - cp_token *token; - tree identifier; - tree attribute; - - /* Look for the identifier. We also allow keywords here; for - example `__attribute__ ((const))' is legal. */ - token = cp_lexer_peek_token (parser->lexer); - if (token->type == CPP_NAME - || token->type == CPP_KEYWORD) - { - tree arguments = NULL_TREE; - - /* Consume the token. */ - token = cp_lexer_consume_token (parser->lexer); - - /* Save away the identifier that indicates which attribute - this is. */ - identifier = token->u.value; - attribute = build_tree_list (identifier, NULL_TREE); - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If it's an `(', then parse the attribute arguments. */ - if (token->type == CPP_OPEN_PAREN) - { - arguments = cp_parser_parenthesized_expression_list - (parser, true, /*cast_p=*/false, - /*non_constant_p=*/NULL); - /* Save the arguments away. */ - TREE_VALUE (attribute) = arguments; - } - - if (arguments != error_mark_node) - { - /* Add this attribute to the list. */ - TREE_CHAIN (attribute) = attribute_list; - attribute_list = attribute; - } - - token = cp_lexer_peek_token (parser->lexer); - } - /* Now, look for more attributes. If the next token isn't a - `,', we're done. */ - if (token->type != CPP_COMMA) - break; - - /* Consume the comma and keep going. */ - cp_lexer_consume_token (parser->lexer); - } - parser->translate_strings_p = save_translate_strings_p; - - /* We built up the list in reverse order. */ - return nreverse (attribute_list); -} - -/* Parse an optional `__extension__' keyword. Returns TRUE if it is - present, and FALSE otherwise. *SAVED_PEDANTIC is set to the - current value of the PEDANTIC flag, regardless of whether or not - the `__extension__' keyword is present. The caller is responsible - for restoring the value of the PEDANTIC flag. */ - -static bool -cp_parser_extension_opt (cp_parser* parser, int* saved_pedantic) -{ - /* Save the old value of the PEDANTIC flag. */ - *saved_pedantic = pedantic; - - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTENSION)) - { - /* Consume the `__extension__' token. */ - cp_lexer_consume_token (parser->lexer); - /* We're not being pedantic while the `__extension__' keyword is - in effect. */ - pedantic = 0; - - return true; - } - - return false; -} - -/* Parse a label declaration. - - label-declaration: - __label__ label-declarator-seq ; - - label-declarator-seq: - identifier , label-declarator-seq - identifier */ - -static void -cp_parser_label_declaration (cp_parser* parser) -{ - /* Look for the `__label__' keyword. */ - cp_parser_require_keyword (parser, RID_LABEL, "`__label__'"); - - while (true) - { - tree identifier; - - /* Look for an identifier. */ - identifier = cp_parser_identifier (parser); - /* If we failed, stop. */ - if (identifier == error_mark_node) - break; - /* Declare it as a label. */ - finish_label_decl (identifier); - /* If the next token is a `;', stop. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) - break; - /* Look for the `,' separating the label declarations. */ - cp_parser_require (parser, CPP_COMMA, "`,'"); - } - - /* Look for the final `;'. */ - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); -} - -/* Support Functions */ - -/* Looks up NAME in the current scope, as given by PARSER->SCOPE. - NAME should have one of the representations used for an - id-expression. If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE - is returned. If PARSER->SCOPE is a dependent type, then a - SCOPE_REF is returned. - - If NAME is a TEMPLATE_ID_EXPR, then it will be immediately - returned; the name was already resolved when the TEMPLATE_ID_EXPR - was formed. Abstractly, such entities should not be passed to this - function, because they do not need to be looked up, but it is - simpler to check for this special case here, rather than at the - call-sites. - - In cases not explicitly covered above, this function returns a - DECL, OVERLOAD, or baselink representing the result of the lookup. - If there was no entity with the indicated NAME, the ERROR_MARK_NODE - is returned. - - If TAG_TYPE is not NONE_TYPE, it indicates an explicit type keyword - (e.g., "struct") that was used. In that case bindings that do not - refer to types are ignored. - - If IS_TEMPLATE is TRUE, bindings that do not refer to templates are - ignored. - - If IS_NAMESPACE is TRUE, bindings that do not refer to namespaces - are ignored. - - If CHECK_DEPENDENCY is TRUE, names are not looked up in dependent - types. - - If AMBIGUOUS_DECLS is non-NULL, *AMBIGUOUS_DECLS is set to a - TREE_LIST of candidates if name-lookup results in an ambiguity, and - NULL_TREE otherwise. */ - -static tree -cp_parser_lookup_name (cp_parser *parser, tree name, - enum tag_types tag_type, - bool is_template, - bool is_namespace, - bool check_dependency, - tree *ambiguous_decls) -{ - int flags = 0; - tree decl; - tree object_type = parser->context->object_type; - - if (!cp_parser_uncommitted_to_tentative_parse_p (parser)) - flags |= LOOKUP_COMPLAIN; - - /* Assume that the lookup will be unambiguous. */ - if (ambiguous_decls) - *ambiguous_decls = NULL_TREE; - - /* Now that we have looked up the name, the OBJECT_TYPE (if any) is - no longer valid. Note that if we are parsing tentatively, and - the parse fails, OBJECT_TYPE will be automatically restored. */ - parser->context->object_type = NULL_TREE; - - if (name == error_mark_node) - return error_mark_node; - - /* A template-id has already been resolved; there is no lookup to - do. */ - if (TREE_CODE (name) == TEMPLATE_ID_EXPR) - return name; - if (BASELINK_P (name)) - { - gcc_assert (TREE_CODE (BASELINK_FUNCTIONS (name)) - == TEMPLATE_ID_EXPR); - return name; - } - - /* A BIT_NOT_EXPR is used to represent a destructor. By this point, - it should already have been checked to make sure that the name - used matches the type being destroyed. */ - if (TREE_CODE (name) == BIT_NOT_EXPR) - { - tree type; - - /* Figure out to which type this destructor applies. */ - if (parser->scope) - type = parser->scope; - else if (object_type) - type = object_type; - else - type = current_class_type; - /* If that's not a class type, there is no destructor. */ - if (!type || !CLASS_TYPE_P (type)) - return error_mark_node; - if (CLASSTYPE_LAZY_DESTRUCTOR (type)) - lazily_declare_fn (sfk_destructor, type); - if (!CLASSTYPE_DESTRUCTORS (type)) - return error_mark_node; - /* If it was a class type, return the destructor. */ - return CLASSTYPE_DESTRUCTORS (type); - } - - /* By this point, the NAME should be an ordinary identifier. If - the id-expression was a qualified name, the qualifying scope is - stored in PARSER->SCOPE at this point. */ - gcc_assert (TREE_CODE (name) == IDENTIFIER_NODE); - - /* Perform the lookup. */ - if (parser->scope) - { - bool dependent_p; - - if (parser->scope == error_mark_node) - return error_mark_node; - - /* If the SCOPE is dependent, the lookup must be deferred until - the template is instantiated -- unless we are explicitly - looking up names in uninstantiated templates. Even then, we - cannot look up the name if the scope is not a class type; it - might, for example, be a template type parameter. */ - dependent_p = (TYPE_P (parser->scope) - && !(parser->in_declarator_p - && currently_open_class (parser->scope)) - && dependent_type_p (parser->scope)); - if ((check_dependency || !CLASS_TYPE_P (parser->scope)) - && dependent_p) - { - if (tag_type) - { - tree type; - - /* The resolution to Core Issue 180 says that `struct - A::B' should be considered a type-name, even if `A' - is dependent. */ - type = make_typename_type (parser->scope, name, tag_type, - /*complain=*/tf_error); - decl = TYPE_NAME (type); - } - else if (is_template - && (cp_parser_next_token_ends_template_argument_p (parser) - || cp_lexer_next_token_is (parser->lexer, - CPP_CLOSE_PAREN))) - decl = make_unbound_class_template (parser->scope, - name, NULL_TREE, - /*complain=*/tf_error); - else - decl = build_qualified_name (/*type=*/NULL_TREE, - parser->scope, name, - is_template); - } - else - { - tree pushed_scope = NULL_TREE; - - /* If PARSER->SCOPE is a dependent type, then it must be a - class type, and we must not be checking dependencies; - otherwise, we would have processed this lookup above. So - that PARSER->SCOPE is not considered a dependent base by - lookup_member, we must enter the scope here. */ - if (dependent_p) - pushed_scope = push_scope (parser->scope); - /* If the PARSER->SCOPE is a template specialization, it - may be instantiated during name lookup. In that case, - errors may be issued. Even if we rollback the current - tentative parse, those errors are valid. */ - decl = lookup_qualified_name (parser->scope, name, - tag_type != none_type, - /*complain=*/true); - if (pushed_scope) - pop_scope (pushed_scope); - } - parser->qualifying_scope = parser->scope; - parser->object_scope = NULL_TREE; - } - else if (object_type) - { - tree object_decl = NULL_TREE; - /* Look up the name in the scope of the OBJECT_TYPE, unless the - OBJECT_TYPE is not a class. */ - if (CLASS_TYPE_P (object_type)) - /* If the OBJECT_TYPE is a template specialization, it may - be instantiated during name lookup. In that case, errors - may be issued. Even if we rollback the current tentative - parse, those errors are valid. */ - object_decl = lookup_member (object_type, - name, - /*protect=*/0, - tag_type != none_type); - /* Look it up in the enclosing context, too. */ - decl = lookup_name_real (name, tag_type != none_type, - /*nonclass=*/0, - /*block_p=*/true, is_namespace, flags); - parser->object_scope = object_type; - parser->qualifying_scope = NULL_TREE; - if (object_decl) - decl = object_decl; - } - else - { - decl = lookup_name_real (name, tag_type != none_type, - /*nonclass=*/0, - /*block_p=*/true, is_namespace, flags); - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - } - - /* If the lookup failed, let our caller know. */ - if (!decl || decl == error_mark_node) - return error_mark_node; - - /* If it's a TREE_LIST, the result of the lookup was ambiguous. */ - if (TREE_CODE (decl) == TREE_LIST) - { - if (ambiguous_decls) - *ambiguous_decls = decl; - /* The error message we have to print is too complicated for - cp_parser_error, so we incorporate its actions directly. */ - if (!cp_parser_simulate_error (parser)) - { - error ("reference to %qD is ambiguous", name); - print_candidates (decl); - } - return error_mark_node; - } - - gcc_assert (DECL_P (decl) - || TREE_CODE (decl) == OVERLOAD - || TREE_CODE (decl) == SCOPE_REF - || TREE_CODE (decl) == UNBOUND_CLASS_TEMPLATE - || BASELINK_P (decl)); - - /* If we have resolved the name of a member declaration, check to - see if the declaration is accessible. When the name resolves to - set of overloaded functions, accessibility is checked when - overload resolution is done. - - During an explicit instantiation, access is not checked at all, - as per [temp.explicit]. */ - if (DECL_P (decl)) - check_accessibility_of_qualified_id (decl, object_type, parser->scope); - - return decl; -} - -/* Like cp_parser_lookup_name, but for use in the typical case where - CHECK_ACCESS is TRUE, IS_TYPE is FALSE, IS_TEMPLATE is FALSE, - IS_NAMESPACE is FALSE, and CHECK_DEPENDENCY is TRUE. */ - -static tree -cp_parser_lookup_name_simple (cp_parser* parser, tree name) -{ - return cp_parser_lookup_name (parser, name, - none_type, - /*is_template=*/false, - /*is_namespace=*/false, - /*check_dependency=*/true, - /*ambiguous_decls=*/NULL); -} - -/* If DECL is a TEMPLATE_DECL that can be treated like a TYPE_DECL in - the current context, return the TYPE_DECL. If TAG_NAME_P is - true, the DECL indicates the class being defined in a class-head, - or declared in an elaborated-type-specifier. - - Otherwise, return DECL. */ - -static tree -cp_parser_maybe_treat_template_as_class (tree decl, bool tag_name_p) -{ - /* If the TEMPLATE_DECL is being declared as part of a class-head, - the translation from TEMPLATE_DECL to TYPE_DECL occurs: - - struct A { - template <typename T> struct B; - }; - - template <typename T> struct A::B {}; - - Similarly, in an elaborated-type-specifier: - - namespace N { struct X{}; } - - struct A { - template <typename T> friend struct N::X; - }; - - However, if the DECL refers to a class type, and we are in - the scope of the class, then the name lookup automatically - finds the TYPE_DECL created by build_self_reference rather - than a TEMPLATE_DECL. For example, in: - - template <class T> struct S { - S s; - }; - - there is no need to handle such case. */ - - if (DECL_CLASS_TEMPLATE_P (decl) && tag_name_p) - return DECL_TEMPLATE_RESULT (decl); - - return decl; -} - -/* If too many, or too few, template-parameter lists apply to the - declarator, issue an error message. Returns TRUE if all went well, - and FALSE otherwise. */ - -static bool -cp_parser_check_declarator_template_parameters (cp_parser* parser, - cp_declarator *declarator) -{ - unsigned num_templates; - - /* We haven't seen any classes that involve template parameters yet. */ - num_templates = 0; - - switch (declarator->kind) - { - case cdk_id: - if (declarator->u.id.qualifying_scope) - { - tree scope; - tree member; - - scope = declarator->u.id.qualifying_scope; - member = declarator->u.id.unqualified_name; - - while (scope && CLASS_TYPE_P (scope)) - { - /* You're supposed to have one `template <...>' - for every template class, but you don't need one - for a full specialization. For example: - - template <class T> struct S{}; - template <> struct S<int> { void f(); }; - void S<int>::f () {} - - is correct; there shouldn't be a `template <>' for - the definition of `S<int>::f'. */ - if (!CLASSTYPE_TEMPLATE_INFO (scope)) - /* If SCOPE does not have template information of any - kind, then it is not a template, nor is it nested - within a template. */ - break; - if (explicit_class_specialization_p (scope)) - break; - if (PRIMARY_TEMPLATE_P (CLASSTYPE_TI_TEMPLATE (scope))) - ++num_templates; - - scope = TYPE_CONTEXT (scope); - } - } - else if (TREE_CODE (declarator->u.id.unqualified_name) - == TEMPLATE_ID_EXPR) - /* If the DECLARATOR has the form `X<y>' then it uses one - additional level of template parameters. */ - ++num_templates; - - return cp_parser_check_template_parameters (parser, - num_templates); - - case cdk_function: - case cdk_array: - case cdk_pointer: - case cdk_reference: - case cdk_ptrmem: - /* APPLE LOCAL blocks 6040305 */ - case cdk_block_pointer: - return (cp_parser_check_declarator_template_parameters - (parser, declarator->declarator)); - - case cdk_error: - return true; - - default: - gcc_unreachable (); - } - return false; -} - -/* NUM_TEMPLATES were used in the current declaration. If that is - invalid, return FALSE and issue an error messages. Otherwise, - return TRUE. */ - -static bool -cp_parser_check_template_parameters (cp_parser* parser, - unsigned num_templates) -{ - /* If there are more template classes than parameter lists, we have - something like: - - template <class T> void S<T>::R<T>::f (); */ - if (parser->num_template_parameter_lists < num_templates) - { - error ("too few template-parameter-lists"); - return false; - } - /* If there are the same number of template classes and parameter - lists, that's OK. */ - if (parser->num_template_parameter_lists == num_templates) - return true; - /* If there are more, but only one more, then we are referring to a - member template. That's OK too. */ - if (parser->num_template_parameter_lists == num_templates + 1) - return true; - /* Otherwise, there are too many template parameter lists. We have - something like: - - template <class T> template <class U> void S::f(); */ - error ("too many template-parameter-lists"); - return false; -} - -/* Parse an optional `::' token indicating that the following name is - from the global namespace. If so, PARSER->SCOPE is set to the - GLOBAL_NAMESPACE. Otherwise, PARSER->SCOPE is set to NULL_TREE, - unless CURRENT_SCOPE_VALID_P is TRUE, in which case it is left alone. - Returns the new value of PARSER->SCOPE, if the `::' token is - present, and NULL_TREE otherwise. */ - -static tree -cp_parser_global_scope_opt (cp_parser* parser, bool current_scope_valid_p) -{ - cp_token *token; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If we're looking at a `::' token then we're starting from the - global namespace, not our current location. */ - if (token->type == CPP_SCOPE) - { - /* Consume the `::' token. */ - cp_lexer_consume_token (parser->lexer); - /* Set the SCOPE so that we know where to start the lookup. */ - parser->scope = global_namespace; - parser->qualifying_scope = global_namespace; - parser->object_scope = NULL_TREE; - - return parser->scope; - } - else if (!current_scope_valid_p) - { - parser->scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - } - - return NULL_TREE; -} - -/* Returns TRUE if the upcoming token sequence is the start of a - constructor declarator. If FRIEND_P is true, the declarator is - preceded by the `friend' specifier. */ - -static bool -cp_parser_constructor_declarator_p (cp_parser *parser, bool friend_p) -{ - bool constructor_p; - tree type_decl = NULL_TREE; - bool nested_name_p; - cp_token *next_token; - - /* The common case is that this is not a constructor declarator, so - try to avoid doing lots of work if at all possible. It's not - valid declare a constructor at function scope. */ - if (parser->in_function_body) - return false; - /* And only certain tokens can begin a constructor declarator. */ - next_token = cp_lexer_peek_token (parser->lexer); - if (next_token->type != CPP_NAME - && next_token->type != CPP_SCOPE - && next_token->type != CPP_NESTED_NAME_SPECIFIER - && next_token->type != CPP_TEMPLATE_ID) - return false; - - /* Parse tentatively; we are going to roll back all of the tokens - consumed here. */ - cp_parser_parse_tentatively (parser); - /* Assume that we are looking at a constructor declarator. */ - constructor_p = true; - - /* Look for the optional `::' operator. */ - cp_parser_global_scope_opt (parser, - /*current_scope_valid_p=*/false); - /* Look for the nested-name-specifier. */ - nested_name_p - = (cp_parser_nested_name_specifier_opt (parser, - /*typename_keyword_p=*/false, - /*check_dependency_p=*/false, - /*type_p=*/false, - /*is_declaration=*/false) - != NULL_TREE); - /* Outside of a class-specifier, there must be a - nested-name-specifier. */ - if (!nested_name_p && - (!at_class_scope_p () || !TYPE_BEING_DEFINED (current_class_type) - || friend_p)) - constructor_p = false; - /* If we still think that this might be a constructor-declarator, - look for a class-name. */ - if (constructor_p) - { - /* If we have: - - template <typename T> struct S { S(); }; - template <typename T> S<T>::S (); - - we must recognize that the nested `S' names a class. - Similarly, for: - - template <typename T> S<T>::S<T> (); - - we must recognize that the nested `S' names a template. */ - type_decl = cp_parser_class_name (parser, - /*typename_keyword_p=*/false, - /*template_keyword_p=*/false, - none_type, - /*check_dependency_p=*/false, - /*class_head_p=*/false, - /*is_declaration=*/false); - /* If there was no class-name, then this is not a constructor. */ - constructor_p = !cp_parser_error_occurred (parser); - } - - /* If we're still considering a constructor, we have to see a `(', - to begin the parameter-declaration-clause, followed by either a - `)', an `...', or a decl-specifier. We need to check for a - type-specifier to avoid being fooled into thinking that: - - S::S (f) (int); - - is a constructor. (It is actually a function named `f' that - takes one parameter (of type `int') and returns a value of type - `S::S'. */ - if (constructor_p - && cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - { - if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN) - && cp_lexer_next_token_is_not (parser->lexer, CPP_ELLIPSIS) - /* A parameter declaration begins with a decl-specifier, - which is either the "attribute" keyword, a storage class - specifier, or (usually) a type-specifier. */ - && !cp_lexer_next_token_is_decl_specifier_keyword (parser->lexer)) - { - tree type; - tree pushed_scope = NULL_TREE; - unsigned saved_num_template_parameter_lists; - - /* Names appearing in the type-specifier should be looked up - in the scope of the class. */ - if (current_class_type) - type = NULL_TREE; - else - { - type = TREE_TYPE (type_decl); - if (TREE_CODE (type) == TYPENAME_TYPE) - { - type = resolve_typename_type (type, - /*only_current_p=*/false); - if (type == error_mark_node) - { - cp_parser_abort_tentative_parse (parser); - return false; - } - } - pushed_scope = push_scope (type); - } - - /* Inside the constructor parameter list, surrounding - template-parameter-lists do not apply. */ - saved_num_template_parameter_lists - = parser->num_template_parameter_lists; - parser->num_template_parameter_lists = 0; - - /* Look for the type-specifier. */ - cp_parser_type_specifier (parser, - CP_PARSER_FLAGS_NONE, - /*decl_specs=*/NULL, - /*is_declarator=*/true, - /*declares_class_or_enum=*/NULL, - /*is_cv_qualifier=*/NULL); - - parser->num_template_parameter_lists - = saved_num_template_parameter_lists; - - /* Leave the scope of the class. */ - if (pushed_scope) - pop_scope (pushed_scope); - - constructor_p = !cp_parser_error_occurred (parser); - } - } - else - constructor_p = false; - /* We did not really want to consume any tokens. */ - cp_parser_abort_tentative_parse (parser); - - return constructor_p; -} - -/* Parse the definition of the function given by the DECL_SPECIFIERS, - ATTRIBUTES, and DECLARATOR. The access checks have been deferred; - they must be performed once we are in the scope of the function. - - Returns the function defined. */ - -static tree -cp_parser_function_definition_from_specifiers_and_declarator - (cp_parser* parser, - cp_decl_specifier_seq *decl_specifiers, - tree attributes, - const cp_declarator *declarator) -{ - tree fn; - bool success_p; - - /* Begin the function-definition. */ - success_p = start_function (decl_specifiers, declarator, attributes); - - /* The things we're about to see are not directly qualified by any - template headers we've seen thus far. */ - reset_specialization (); - - /* If there were names looked up in the decl-specifier-seq that we - did not check, check them now. We must wait until we are in the - scope of the function to perform the checks, since the function - might be a friend. */ - perform_deferred_access_checks (); - - if (!success_p) - { - /* Skip the entire function. */ - cp_parser_skip_to_end_of_block_or_statement (parser); - fn = error_mark_node; - } -/* APPLE LOCAL begin mainline 2006-12-02 5128086 */ \ - else if (DECL_INITIAL (current_function_decl) != error_mark_node) - { - /* Seen already, skip it. An error message has already been output. */ - cp_parser_skip_to_end_of_block_or_statement (parser); - fn = current_function_decl; - current_function_decl = NULL_TREE; - /* If this is a function from a class, pop the nested class. */ - if (current_class_name) - pop_nested_class (); - } -/* APPLE LOCAL end mainline 2006-12-02 5128086 */ \ - else - fn = cp_parser_function_definition_after_declarator (parser, - /*inline_p=*/false); - - return fn; -} - -/* Parse the part of a function-definition that follows the - declarator. INLINE_P is TRUE iff this function is an inline - function defined with a class-specifier. - - Returns the function defined. */ - -static tree -cp_parser_function_definition_after_declarator (cp_parser* parser, - bool inline_p) -{ - tree fn; - bool ctor_initializer_p = false; - bool saved_in_unbraced_linkage_specification_p; - bool saved_in_function_body; - unsigned saved_num_template_parameter_lists; - - saved_in_function_body = parser->in_function_body; - parser->in_function_body = true; - /* If the next token is `return', then the code may be trying to - make use of the "named return value" extension that G++ used to - support. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_RETURN)) - { - /* Consume the `return' keyword. */ - cp_lexer_consume_token (parser->lexer); - /* Look for the identifier that indicates what value is to be - returned. */ - cp_parser_identifier (parser); - /* Issue an error message. */ - error ("named return values are no longer supported"); - /* Skip tokens until we reach the start of the function body. */ - while (true) - { - cp_token *token = cp_lexer_peek_token (parser->lexer); - if (token->type == CPP_OPEN_BRACE - || token->type == CPP_EOF - || token->type == CPP_PRAGMA_EOL) - break; - cp_lexer_consume_token (parser->lexer); - } - } - /* The `extern' in `extern "C" void f () { ... }' does not apply to - anything declared inside `f'. */ - saved_in_unbraced_linkage_specification_p - = parser->in_unbraced_linkage_specification_p; - parser->in_unbraced_linkage_specification_p = false; - /* Inside the function, surrounding template-parameter-lists do not - apply. */ - saved_num_template_parameter_lists - = parser->num_template_parameter_lists; - parser->num_template_parameter_lists = 0; - /* If the next token is `try', then we are looking at a - function-try-block. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TRY)) - ctor_initializer_p = cp_parser_function_try_block (parser); - /* A function-try-block includes the function-body, so we only do - this next part if we're not processing a function-try-block. */ - else - ctor_initializer_p - = cp_parser_ctor_initializer_opt_and_function_body (parser); - - /* Finish the function. */ - fn = finish_function ((ctor_initializer_p ? 1 : 0) | - (inline_p ? 2 : 0)); - /* Generate code for it, if necessary. */ - expand_or_defer_fn (fn); - /* Restore the saved values. */ - parser->in_unbraced_linkage_specification_p - = saved_in_unbraced_linkage_specification_p; - parser->num_template_parameter_lists - = saved_num_template_parameter_lists; - parser->in_function_body = saved_in_function_body; - - return fn; -} - -/* Parse a template-declaration, assuming that the `export' (and - `extern') keywords, if present, has already been scanned. MEMBER_P - is as for cp_parser_template_declaration. */ - -static void -cp_parser_template_declaration_after_export (cp_parser* parser, bool member_p) -{ - tree decl = NULL_TREE; - VEC (deferred_access_check,gc) *checks; - tree parameter_list; - bool friend_p = false; - bool need_lang_pop; - - /* Look for the `template' keyword. */ - if (!cp_parser_require_keyword (parser, RID_TEMPLATE, "`template'")) - return; - - /* And the `<'. */ - if (!cp_parser_require (parser, CPP_LESS, "`<'")) - return; - if (at_class_scope_p () && current_function_decl) - { - /* 14.5.2.2 [temp.mem] - - A local class shall not have member templates. */ - error ("invalid declaration of member template in local class"); - cp_parser_skip_to_end_of_block_or_statement (parser); - return; - } - /* [temp] - - A template ... shall not have C linkage. */ - if (current_lang_name == lang_name_c) - { - error ("template with C linkage"); - /* Give it C++ linkage to avoid confusing other parts of the - front end. */ - push_lang_context (lang_name_cplusplus); - need_lang_pop = true; - } - else - need_lang_pop = false; - - /* We cannot perform access checks on the template parameter - declarations until we know what is being declared, just as we - cannot check the decl-specifier list. */ - push_deferring_access_checks (dk_deferred); - - /* If the next token is `>', then we have an invalid - specialization. Rather than complain about an invalid template - parameter, issue an error message here. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER)) - { - cp_parser_error (parser, "invalid explicit specialization"); - begin_specialization (); - parameter_list = NULL_TREE; - } - else - /* Parse the template parameters. */ - parameter_list = cp_parser_template_parameter_list (parser); - - /* Get the deferred access checks from the parameter list. These - will be checked once we know what is being declared, as for a - member template the checks must be performed in the scope of the - class containing the member. */ - checks = get_deferred_access_checks (); - - /* Look for the `>'. */ - cp_parser_skip_to_end_of_template_parameter_list (parser); - /* We just processed one more parameter list. */ - ++parser->num_template_parameter_lists; - /* If the next token is `template', there are more template - parameters. */ - if (cp_lexer_next_token_is_keyword (parser->lexer, - RID_TEMPLATE)) - cp_parser_template_declaration_after_export (parser, member_p); - else - { - /* There are no access checks when parsing a template, as we do not - know if a specialization will be a friend. */ - push_deferring_access_checks (dk_no_check); - decl = cp_parser_single_declaration (parser, - checks, - member_p, - &friend_p); - pop_deferring_access_checks (); - - /* If this is a member template declaration, let the front - end know. */ - if (member_p && !friend_p && decl) - { - if (TREE_CODE (decl) == TYPE_DECL) - cp_parser_check_access_in_redeclaration (decl); - - decl = finish_member_template_decl (decl); - } - else if (friend_p && decl && TREE_CODE (decl) == TYPE_DECL) - make_friend_class (current_class_type, TREE_TYPE (decl), - /*complain=*/true); - } - /* We are done with the current parameter list. */ - --parser->num_template_parameter_lists; - - pop_deferring_access_checks (); - - /* Finish up. */ - finish_template_decl (parameter_list); - - /* Register member declarations. */ - if (member_p && !friend_p && decl && !DECL_CLASS_TEMPLATE_P (decl)) - finish_member_declaration (decl); - /* For the erroneous case of a template with C linkage, we pushed an - implicit C++ linkage scope; exit that scope now. */ - if (need_lang_pop) - pop_lang_context (); - /* If DECL is a function template, we must return to parse it later. - (Even though there is no definition, there might be default - arguments that need handling.) */ - if (member_p && decl - && (TREE_CODE (decl) == FUNCTION_DECL - || DECL_FUNCTION_TEMPLATE_P (decl))) - TREE_VALUE (parser->unparsed_functions_queues) - = tree_cons (NULL_TREE, decl, - TREE_VALUE (parser->unparsed_functions_queues)); -} - -/* Perform the deferred access checks from a template-parameter-list. - CHECKS is a TREE_LIST of access checks, as returned by - get_deferred_access_checks. */ - -static void -cp_parser_perform_template_parameter_access_checks (VEC (deferred_access_check,gc)* checks) -{ - ++processing_template_parmlist; - perform_access_checks (checks); - --processing_template_parmlist; -} - -/* Parse a `decl-specifier-seq [opt] init-declarator [opt] ;' or - `function-definition' sequence. MEMBER_P is true, this declaration - appears in a class scope. - - Returns the DECL for the declared entity. If FRIEND_P is non-NULL, - *FRIEND_P is set to TRUE iff the declaration is a friend. */ - -static tree -cp_parser_single_declaration (cp_parser* parser, - VEC (deferred_access_check,gc)* checks, - bool member_p, - bool* friend_p) -{ - int declares_class_or_enum; - tree decl = NULL_TREE; - cp_decl_specifier_seq decl_specifiers; - bool function_definition_p = false; - - /* This function is only used when processing a template - declaration. */ - gcc_assert (innermost_scope_kind () == sk_template_parms - || innermost_scope_kind () == sk_template_spec); - - /* Defer access checks until we know what is being declared. */ - push_deferring_access_checks (dk_deferred); - - /* Try the `decl-specifier-seq [opt] init-declarator [opt]' - alternative. */ - cp_parser_decl_specifier_seq (parser, - CP_PARSER_FLAGS_OPTIONAL, - &decl_specifiers, - &declares_class_or_enum); - if (friend_p) - *friend_p = cp_parser_friend_p (&decl_specifiers); - - /* There are no template typedefs. */ - if (decl_specifiers.specs[(int) ds_typedef]) - { - error ("template declaration of %qs", "typedef"); - decl = error_mark_node; - } - - /* Gather up the access checks that occurred the - decl-specifier-seq. */ - stop_deferring_access_checks (); - - /* Check for the declaration of a template class. */ - if (declares_class_or_enum) - { - if (cp_parser_declares_only_class_p (parser)) - { - decl = shadow_tag (&decl_specifiers); - - /* In this case: - - struct C { - friend template <typename T> struct A<T>::B; - }; - - A<T>::B will be represented by a TYPENAME_TYPE, and - therefore not recognized by shadow_tag. */ - if (friend_p && *friend_p - && !decl - && decl_specifiers.type - && TYPE_P (decl_specifiers.type)) - decl = decl_specifiers.type; - - if (decl && decl != error_mark_node) - decl = TYPE_NAME (decl); - else - decl = error_mark_node; - - /* Perform access checks for template parameters. */ - cp_parser_perform_template_parameter_access_checks (checks); - } - } - /* If it's not a template class, try for a template function. If - the next token is a `;', then this declaration does not declare - anything. But, if there were errors in the decl-specifiers, then - the error might well have come from an attempted class-specifier. - In that case, there's no need to warn about a missing declarator. */ - if (!decl - && (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON) - || decl_specifiers.type != error_mark_node)) - decl = cp_parser_init_declarator (parser, - &decl_specifiers, - checks, - /*function_definition_allowed_p=*/true, - member_p, - declares_class_or_enum, - &function_definition_p); - - pop_deferring_access_checks (); - - /* Clear any current qualification; whatever comes next is the start - of something new. */ - parser->scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - /* Look for a trailing `;' after the declaration. */ - if (!function_definition_p - && (decl == error_mark_node - || !cp_parser_require (parser, CPP_SEMICOLON, "`;'"))) - cp_parser_skip_to_end_of_block_or_statement (parser); - - return decl; -} - -/* Parse a cast-expression that is not the operand of a unary "&". */ - -static tree -cp_parser_simple_cast_expression (cp_parser *parser) -{ - return cp_parser_cast_expression (parser, /*address_p=*/false, - /*cast_p=*/false); -} - -/* Parse a functional cast to TYPE. Returns an expression - representing the cast. */ - -static tree -cp_parser_functional_cast (cp_parser* parser, tree type) -{ - tree expression_list; - tree cast; - - expression_list - = cp_parser_parenthesized_expression_list (parser, false, - /*cast_p=*/true, - /*non_constant_p=*/NULL); - - cast = build_functional_cast (type, expression_list); - /* [expr.const]/1: In an integral constant expression "only type - conversions to integral or enumeration type can be used". */ - if (TREE_CODE (type) == TYPE_DECL) - type = TREE_TYPE (type); - if (cast != error_mark_node - && !cast_valid_in_integral_constant_expression_p (type) - && (cp_parser_non_integral_constant_expression - (parser, "a call to a constructor"))) - return error_mark_node; - return cast; -} - -/* Save the tokens that make up the body of a member function defined - in a class-specifier. The DECL_SPECIFIERS and DECLARATOR have - already been parsed. The ATTRIBUTES are any GNU "__attribute__" - specifiers applied to the declaration. Returns the FUNCTION_DECL - for the member function. */ - -static tree -cp_parser_save_member_function_body (cp_parser* parser, - cp_decl_specifier_seq *decl_specifiers, - cp_declarator *declarator, - tree attributes) -{ - cp_token *first; - cp_token *last; - tree fn; - - /* Create the function-declaration. */ - fn = start_method (decl_specifiers, declarator, attributes); - /* If something went badly wrong, bail out now. */ - if (fn == error_mark_node) - { - /* If there's a function-body, skip it. */ - if (cp_parser_token_starts_function_definition_p - (cp_lexer_peek_token (parser->lexer))) - cp_parser_skip_to_end_of_block_or_statement (parser); - return error_mark_node; - } - - /* Remember it, if there default args to post process. */ - cp_parser_save_default_args (parser, fn); - - /* Save away the tokens that make up the body of the - function. */ - first = parser->lexer->next_token; - cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0); - /* Handle function try blocks. */ - while (cp_lexer_next_token_is_keyword (parser->lexer, RID_CATCH)) - cp_parser_cache_group (parser, CPP_CLOSE_BRACE, /*depth=*/0); - last = parser->lexer->next_token; - - /* Save away the inline definition; we will process it when the - class is complete. */ - DECL_PENDING_INLINE_INFO (fn) = cp_token_cache_new (first, last); - DECL_PENDING_INLINE_P (fn) = 1; - - /* We need to know that this was defined in the class, so that - friend templates are handled correctly. */ - DECL_INITIALIZED_IN_CLASS_P (fn) = 1; - - /* We're done with the inline definition. */ - finish_method (fn); - - /* Add FN to the queue of functions to be parsed later. */ - TREE_VALUE (parser->unparsed_functions_queues) - = tree_cons (NULL_TREE, fn, - TREE_VALUE (parser->unparsed_functions_queues)); - - return fn; -} - -/* Parse a template-argument-list, as well as the trailing ">" (but - not the opening ">"). See cp_parser_template_argument_list for the - return value. */ - -static tree -cp_parser_enclosed_template_argument_list (cp_parser* parser) -{ - tree arguments; - tree saved_scope; - tree saved_qualifying_scope; - tree saved_object_scope; - bool saved_greater_than_is_operator_p; - bool saved_skip_evaluation; - - /* [temp.names] - - When parsing a template-id, the first non-nested `>' is taken as - the end of the template-argument-list rather than a greater-than - operator. */ - saved_greater_than_is_operator_p - = parser->greater_than_is_operator_p; - parser->greater_than_is_operator_p = false; - /* Parsing the argument list may modify SCOPE, so we save it - here. */ - saved_scope = parser->scope; - saved_qualifying_scope = parser->qualifying_scope; - saved_object_scope = parser->object_scope; - /* We need to evaluate the template arguments, even though this - template-id may be nested within a "sizeof". */ - saved_skip_evaluation = skip_evaluation; - skip_evaluation = false; - /* Parse the template-argument-list itself. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_GREATER)) - arguments = NULL_TREE; - else - arguments = cp_parser_template_argument_list (parser); - /* Look for the `>' that ends the template-argument-list. If we find - a '>>' instead, it's probably just a typo. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_RSHIFT)) - { - if (!saved_greater_than_is_operator_p) - { - /* If we're in a nested template argument list, the '>>' has - to be a typo for '> >'. We emit the error message, but we - continue parsing and we push a '>' as next token, so that - the argument list will be parsed correctly. Note that the - global source location is still on the token before the - '>>', so we need to say explicitly where we want it. */ - cp_token *token = cp_lexer_peek_token (parser->lexer); - error ("%H%<>>%> should be %<> >%> " - "within a nested template argument list", - &token->location); - - /* ??? Proper recovery should terminate two levels of - template argument list here. */ - token->type = CPP_GREATER; - } - else - { - /* If this is not a nested template argument list, the '>>' - is a typo for '>'. Emit an error message and continue. - Same deal about the token location, but here we can get it - right by consuming the '>>' before issuing the diagnostic. */ - cp_lexer_consume_token (parser->lexer); - error ("spurious %<>>%>, use %<>%> to terminate " - "a template argument list"); - } - } - else - cp_parser_skip_to_end_of_template_parameter_list (parser); - /* The `>' token might be a greater-than operator again now. */ - parser->greater_than_is_operator_p - = saved_greater_than_is_operator_p; - /* Restore the SAVED_SCOPE. */ - parser->scope = saved_scope; - parser->qualifying_scope = saved_qualifying_scope; - parser->object_scope = saved_object_scope; - skip_evaluation = saved_skip_evaluation; - - return arguments; -} - -/* MEMBER_FUNCTION is a member function, or a friend. If default - arguments, or the body of the function have not yet been parsed, - parse them now. */ - -static void -cp_parser_late_parsing_for_member (cp_parser* parser, tree member_function) -{ - /* If this member is a template, get the underlying - FUNCTION_DECL. */ - if (DECL_FUNCTION_TEMPLATE_P (member_function)) - member_function = DECL_TEMPLATE_RESULT (member_function); - - /* There should not be any class definitions in progress at this - point; the bodies of members are only parsed outside of all class - definitions. */ - gcc_assert (parser->num_classes_being_defined == 0); - /* While we're parsing the member functions we might encounter more - classes. We want to handle them right away, but we don't want - them getting mixed up with functions that are currently in the - queue. */ - parser->unparsed_functions_queues - = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues); - - /* Make sure that any template parameters are in scope. */ - maybe_begin_member_template_processing (member_function); - - /* If the body of the function has not yet been parsed, parse it - now. */ - if (DECL_PENDING_INLINE_P (member_function)) - { - tree function_scope; - cp_token_cache *tokens; - - /* The function is no longer pending; we are processing it. */ - tokens = DECL_PENDING_INLINE_INFO (member_function); - DECL_PENDING_INLINE_INFO (member_function) = NULL; - DECL_PENDING_INLINE_P (member_function) = 0; - - /* If this is a local class, enter the scope of the containing - function. */ - function_scope = current_function_decl; - if (function_scope) - push_function_context_to (function_scope); - - - /* Push the body of the function onto the lexer stack. */ - cp_parser_push_lexer_for_tokens (parser, tokens); - - /* Let the front end know that we going to be defining this - function. */ - start_preparsed_function (member_function, NULL_TREE, - SF_PRE_PARSED | SF_INCLASS_INLINE); - - /* Don't do access checking if it is a templated function. */ - if (processing_template_decl) - push_deferring_access_checks (dk_no_check); - - /* Now, parse the body of the function. */ - cp_parser_function_definition_after_declarator (parser, - /*inline_p=*/true); - - if (processing_template_decl) - pop_deferring_access_checks (); - - /* Leave the scope of the containing function. */ - if (function_scope) - pop_function_context_from (function_scope); - cp_parser_pop_lexer (parser); - } - - /* Remove any template parameters from the symbol table. */ - maybe_end_member_template_processing (); - - /* Restore the queue. */ - parser->unparsed_functions_queues - = TREE_CHAIN (parser->unparsed_functions_queues); -} - -/* If DECL contains any default args, remember it on the unparsed - functions queue. */ - -static void -cp_parser_save_default_args (cp_parser* parser, tree decl) -{ - tree probe; - - for (probe = TYPE_ARG_TYPES (TREE_TYPE (decl)); - probe; - probe = TREE_CHAIN (probe)) - if (TREE_PURPOSE (probe)) - { - TREE_PURPOSE (parser->unparsed_functions_queues) - = tree_cons (current_class_type, decl, - TREE_PURPOSE (parser->unparsed_functions_queues)); - break; - } -} - -/* FN is a FUNCTION_DECL which may contains a parameter with an - unparsed DEFAULT_ARG. Parse the default args now. This function - assumes that the current scope is the scope in which the default - argument should be processed. */ - -static void -cp_parser_late_parsing_default_args (cp_parser *parser, tree fn) -{ - bool saved_local_variables_forbidden_p; - tree parm; - - /* While we're parsing the default args, we might (due to the - statement expression extension) encounter more classes. We want - to handle them right away, but we don't want them getting mixed - up with default args that are currently in the queue. */ - parser->unparsed_functions_queues - = tree_cons (NULL_TREE, NULL_TREE, parser->unparsed_functions_queues); - - /* Local variable names (and the `this' keyword) may not appear - in a default argument. */ - saved_local_variables_forbidden_p = parser->local_variables_forbidden_p; - parser->local_variables_forbidden_p = true; - - for (parm = TYPE_ARG_TYPES (TREE_TYPE (fn)); - parm; - parm = TREE_CHAIN (parm)) - { - cp_token_cache *tokens; - tree default_arg = TREE_PURPOSE (parm); - tree parsed_arg; - VEC(tree,gc) *insts; - tree copy; - unsigned ix; - - if (!default_arg) - continue; - - if (TREE_CODE (default_arg) != DEFAULT_ARG) - /* This can happen for a friend declaration for a function - already declared with default arguments. */ - continue; - - /* Push the saved tokens for the default argument onto the parser's - lexer stack. */ - tokens = DEFARG_TOKENS (default_arg); - cp_parser_push_lexer_for_tokens (parser, tokens); - - /* Parse the assignment-expression. */ - parsed_arg = cp_parser_assignment_expression (parser, /*cast_p=*/false); - - if (!processing_template_decl) - parsed_arg = check_default_argument (TREE_VALUE (parm), parsed_arg); - - TREE_PURPOSE (parm) = parsed_arg; - - /* Update any instantiations we've already created. */ - for (insts = DEFARG_INSTANTIATIONS (default_arg), ix = 0; - VEC_iterate (tree, insts, ix, copy); ix++) - TREE_PURPOSE (copy) = parsed_arg; - - /* If the token stream has not been completely used up, then - there was extra junk after the end of the default - argument. */ - if (!cp_lexer_next_token_is (parser->lexer, CPP_EOF)) - cp_parser_error (parser, "expected %<,%>"); - - /* Revert to the main lexer. */ - cp_parser_pop_lexer (parser); - } - - /* Make sure no default arg is missing. */ - check_default_args (fn); - - /* Restore the state of local_variables_forbidden_p. */ - parser->local_variables_forbidden_p = saved_local_variables_forbidden_p; - - /* Restore the queue. */ - parser->unparsed_functions_queues - = TREE_CHAIN (parser->unparsed_functions_queues); -} - -/* Parse the operand of `sizeof' (or a similar operator). Returns - either a TYPE or an expression, depending on the form of the - input. The KEYWORD indicates which kind of expression we have - encountered. */ - -static tree -cp_parser_sizeof_operand (cp_parser* parser, enum rid keyword) -{ - static const char *format; - tree expr = NULL_TREE; - const char *saved_message; - bool saved_integral_constant_expression_p; - bool saved_non_integral_constant_expression_p; - - /* Initialize FORMAT the first time we get here. */ - if (!format) - format = "types may not be defined in '%s' expressions"; - - /* Types cannot be defined in a `sizeof' expression. Save away the - old message. */ - saved_message = parser->type_definition_forbidden_message; - /* And create the new one. */ - parser->type_definition_forbidden_message - = XNEWVEC (const char, strlen (format) - + strlen (IDENTIFIER_POINTER (ridpointers[keyword])) - + 1 /* `\0' */); - sprintf ((char *) parser->type_definition_forbidden_message, - format, IDENTIFIER_POINTER (ridpointers[keyword])); - - /* The restrictions on constant-expressions do not apply inside - sizeof expressions. */ - saved_integral_constant_expression_p - = parser->integral_constant_expression_p; - saved_non_integral_constant_expression_p - = parser->non_integral_constant_expression_p; - parser->integral_constant_expression_p = false; - - /* Do not actually evaluate the expression. */ - ++skip_evaluation; - /* If it's a `(', then we might be looking at the type-id - construction. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - { - tree type; - bool saved_in_type_id_in_expr_p; - - /* We can't be sure yet whether we're looking at a type-id or an - expression. */ - cp_parser_parse_tentatively (parser); - /* Consume the `('. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the type-id. */ - saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p; - parser->in_type_id_in_expr_p = true; - type = cp_parser_type_id (parser); - parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p; - /* Now, look for the trailing `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "%<)%>"); - /* If all went well, then we're done. */ - if (cp_parser_parse_definitely (parser)) - { - cp_decl_specifier_seq decl_specs; - - /* Build a trivial decl-specifier-seq. */ - clear_decl_specs (&decl_specs); - decl_specs.type = type; - - /* Call grokdeclarator to figure out what type this is. */ - expr = grokdeclarator (NULL, - &decl_specs, - TYPENAME, - /*initialized=*/0, - /*attrlist=*/NULL); - } - } - - /* If the type-id production did not work out, then we must be - looking at the unary-expression production. */ - if (!expr) - expr = cp_parser_unary_expression (parser, /*address_p=*/false, - /*cast_p=*/false); - /* Go back to evaluating expressions. */ - --skip_evaluation; - - /* Free the message we created. */ - free ((char *) parser->type_definition_forbidden_message); - /* And restore the old one. */ - parser->type_definition_forbidden_message = saved_message; - parser->integral_constant_expression_p - = saved_integral_constant_expression_p; - parser->non_integral_constant_expression_p - = saved_non_integral_constant_expression_p; - - return expr; -} - -/* If the current declaration has no declarator, return true. */ - -static bool -cp_parser_declares_only_class_p (cp_parser *parser) -{ - /* If the next token is a `;' or a `,' then there is no - declarator. */ - return (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON) - || cp_lexer_next_token_is (parser->lexer, CPP_COMMA)); -} - -/* Update the DECL_SPECS to reflect the storage class indicated by - KEYWORD. */ - -static void -cp_parser_set_storage_class (cp_parser *parser, - cp_decl_specifier_seq *decl_specs, - enum rid keyword) -{ - cp_storage_class storage_class; - - if (parser->in_unbraced_linkage_specification_p) - { - error ("invalid use of %qD in linkage specification", - ridpointers[keyword]); - return; - } - else if (decl_specs->storage_class != sc_none) - { - decl_specs->conflicting_specifiers_p = true; - return; - } - - if ((keyword == RID_EXTERN || keyword == RID_STATIC) - && decl_specs->specs[(int) ds_thread]) - { - error ("%<__thread%> before %qD", ridpointers[keyword]); - decl_specs->specs[(int) ds_thread] = 0; - } - - switch (keyword) - { - case RID_AUTO: - storage_class = sc_auto; - break; - case RID_REGISTER: - storage_class = sc_register; - break; - case RID_STATIC: - storage_class = sc_static; - break; - case RID_EXTERN: - storage_class = sc_extern; - break; - case RID_MUTABLE: - storage_class = sc_mutable; - break; - default: - gcc_unreachable (); - } - decl_specs->storage_class = storage_class; - - /* A storage class specifier cannot be applied alongside a typedef - specifier. If there is a typedef specifier present then set - conflicting_specifiers_p which will trigger an error later - on in grokdeclarator. */ - if (decl_specs->specs[(int)ds_typedef]) - decl_specs->conflicting_specifiers_p = true; -} - -/* Update the DECL_SPECS to reflect the TYPE_SPEC. If USER_DEFINED_P - is true, the type is a user-defined type; otherwise it is a - built-in type specified by a keyword. */ - -static void -cp_parser_set_decl_spec_type (cp_decl_specifier_seq *decl_specs, - tree type_spec, - bool user_defined_p) -{ - decl_specs->any_specifiers_p = true; - - /* If the user tries to redeclare bool or wchar_t (with, for - example, in "typedef int wchar_t;") we remember that this is what - happened. In system headers, we ignore these declarations so - that G++ can work with system headers that are not C++-safe. */ - if (decl_specs->specs[(int) ds_typedef] - && !user_defined_p - && (type_spec == boolean_type_node - || type_spec == wchar_type_node) - && (decl_specs->type - || decl_specs->specs[(int) ds_long] - || decl_specs->specs[(int) ds_short] - || decl_specs->specs[(int) ds_unsigned] - || decl_specs->specs[(int) ds_signed])) - { - decl_specs->redefined_builtin_type = type_spec; - if (!decl_specs->type) - { - decl_specs->type = type_spec; - decl_specs->user_defined_type_p = false; - } - } - else if (decl_specs->type) - decl_specs->multiple_types_p = true; - else - { - decl_specs->type = type_spec; - decl_specs->user_defined_type_p = user_defined_p; - decl_specs->redefined_builtin_type = NULL_TREE; - } -} - -/* DECL_SPECIFIERS is the representation of a decl-specifier-seq. - Returns TRUE iff `friend' appears among the DECL_SPECIFIERS. */ - -static bool -cp_parser_friend_p (const cp_decl_specifier_seq *decl_specifiers) -{ - return decl_specifiers->specs[(int) ds_friend] != 0; -} - -/* If the next token is of the indicated TYPE, consume it. Otherwise, - issue an error message indicating that TOKEN_DESC was expected. - - Returns the token consumed, if the token had the appropriate type. - Otherwise, returns NULL. */ - -static cp_token * -cp_parser_require (cp_parser* parser, - enum cpp_ttype type, - const char* token_desc) -{ - if (cp_lexer_next_token_is (parser->lexer, type)) - return cp_lexer_consume_token (parser->lexer); - else - { - /* Output the MESSAGE -- unless we're parsing tentatively. */ - if (!cp_parser_simulate_error (parser)) - { - char *message = concat ("expected ", token_desc, NULL); - cp_parser_error (parser, message); - free (message); - } - return NULL; - } -} - -/* An error message is produced if the next token is not '>'. - All further tokens are skipped until the desired token is - found or '{', '}', ';' or an unbalanced ')' or ']'. */ - -static void -cp_parser_skip_to_end_of_template_parameter_list (cp_parser* parser) -{ - /* Current level of '< ... >'. */ - unsigned level = 0; - /* Ignore '<' and '>' nested inside '( ... )' or '[ ... ]'. */ - unsigned nesting_depth = 0; - - /* Are we ready, yet? If not, issue error message. */ - if (cp_parser_require (parser, CPP_GREATER, "%<>%>")) - return; - - /* Skip tokens until the desired token is found. */ - while (true) - { - /* Peek at the next token. */ - switch (cp_lexer_peek_token (parser->lexer)->type) - { - case CPP_LESS: - if (!nesting_depth) - ++level; - break; - - case CPP_GREATER: - if (!nesting_depth && level-- == 0) - { - /* We've reached the token we want, consume it and stop. */ - cp_lexer_consume_token (parser->lexer); - return; - } - break; - - case CPP_OPEN_PAREN: - case CPP_OPEN_SQUARE: - ++nesting_depth; - break; - - case CPP_CLOSE_PAREN: - case CPP_CLOSE_SQUARE: - if (nesting_depth-- == 0) - return; - break; - - case CPP_EOF: - case CPP_PRAGMA_EOL: - case CPP_SEMICOLON: - case CPP_OPEN_BRACE: - case CPP_CLOSE_BRACE: - /* The '>' was probably forgotten, don't look further. */ - return; - - default: - break; - } - - /* Consume this token. */ - cp_lexer_consume_token (parser->lexer); - } -} - -/* If the next token is the indicated keyword, consume it. Otherwise, - issue an error message indicating that TOKEN_DESC was expected. - - Returns the token consumed, if the token had the appropriate type. - Otherwise, returns NULL. */ - -static cp_token * -cp_parser_require_keyword (cp_parser* parser, - enum rid keyword, - const char* token_desc) -{ - cp_token *token = cp_parser_require (parser, CPP_KEYWORD, token_desc); - - if (token && token->keyword != keyword) - { - dyn_string_t error_msg; - - /* Format the error message. */ - error_msg = dyn_string_new (0); - dyn_string_append_cstr (error_msg, "expected "); - dyn_string_append_cstr (error_msg, token_desc); - cp_parser_error (parser, error_msg->s); - dyn_string_delete (error_msg); - return NULL; - } - - return token; -} - -/* Returns TRUE iff TOKEN is a token that can begin the body of a - function-definition. */ - -static bool -cp_parser_token_starts_function_definition_p (cp_token* token) -{ - return (/* An ordinary function-body begins with an `{'. */ - token->type == CPP_OPEN_BRACE - /* A ctor-initializer begins with a `:'. */ - || token->type == CPP_COLON - /* A function-try-block begins with `try'. */ - || token->keyword == RID_TRY - /* The named return value extension begins with `return'. */ - || token->keyword == RID_RETURN); -} - -/* Returns TRUE iff the next token is the ":" or "{" beginning a class - definition. */ - -static bool -cp_parser_next_token_starts_class_definition_p (cp_parser *parser) -{ - cp_token *token; - - token = cp_lexer_peek_token (parser->lexer); - return (token->type == CPP_OPEN_BRACE || token->type == CPP_COLON); -} - -/* Returns TRUE iff the next token is the "," or ">" ending a - template-argument. */ - -static bool -cp_parser_next_token_ends_template_argument_p (cp_parser *parser) -{ - cp_token *token; - - token = cp_lexer_peek_token (parser->lexer); - return (token->type == CPP_COMMA || token->type == CPP_GREATER); -} - -/* Returns TRUE iff the n-th token is a "<", or the n-th is a "[" and the - (n+1)-th is a ":" (which is a possible digraph typo for "< ::"). */ - -static bool -cp_parser_nth_token_starts_template_argument_list_p (cp_parser * parser, - size_t n) -{ - cp_token *token; - - token = cp_lexer_peek_nth_token (parser->lexer, n); - if (token->type == CPP_LESS) - return true; - /* Check for the sequence `<::' in the original code. It would be lexed as - `[:', where `[' is a digraph, and there is no whitespace before - `:'. */ - if (token->type == CPP_OPEN_SQUARE && token->flags & DIGRAPH) - { - cp_token *token2; - token2 = cp_lexer_peek_nth_token (parser->lexer, n+1); - if (token2->type == CPP_COLON && !(token2->flags & PREV_WHITE)) - return true; - } - return false; -} - -/* Returns the kind of tag indicated by TOKEN, if it is a class-key, - or none_type otherwise. */ - -static enum tag_types -cp_parser_token_is_class_key (cp_token* token) -{ - switch (token->keyword) - { - case RID_CLASS: - return class_type; - case RID_STRUCT: - return record_type; - case RID_UNION: - return union_type; - - default: - return none_type; - } -} - -/* Issue an error message if the CLASS_KEY does not match the TYPE. */ - -static void -cp_parser_check_class_key (enum tag_types class_key, tree type) -{ - if ((TREE_CODE (type) == UNION_TYPE) != (class_key == union_type)) - pedwarn ("%qs tag used in naming %q#T", - class_key == union_type ? "union" - : class_key == record_type ? "struct" : "class", - type); -} - -/* Issue an error message if DECL is redeclared with different - access than its original declaration [class.access.spec/3]. - This applies to nested classes and nested class templates. - [class.mem/1]. */ - -static void -cp_parser_check_access_in_redeclaration (tree decl) -{ - if (!CLASS_TYPE_P (TREE_TYPE (decl))) - return; - - if ((TREE_PRIVATE (decl) - != (current_access_specifier == access_private_node)) - || (TREE_PROTECTED (decl) - != (current_access_specifier == access_protected_node))) - error ("%qD redeclared with different access", decl); -} - -/* Look for the `template' keyword, as a syntactic disambiguator. - Return TRUE iff it is present, in which case it will be - consumed. */ - -static bool -cp_parser_optional_template_keyword (cp_parser *parser) -{ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_TEMPLATE)) - { - /* The `template' keyword can only be used within templates; - outside templates the parser can always figure out what is a - template and what is not. */ - if (!processing_template_decl) - { - error ("%<template%> (as a disambiguator) is only allowed " - "within templates"); - /* If this part of the token stream is rescanned, the same - error message would be generated. So, we purge the token - from the stream. */ - cp_lexer_purge_token (parser->lexer); - return false; - } - else - { - /* Consume the `template' keyword. */ - cp_lexer_consume_token (parser->lexer); - return true; - } - } - - return false; -} - -/* The next token is a CPP_NESTED_NAME_SPECIFIER. Consume the token, - set PARSER->SCOPE, and perform other related actions. */ - -static void -cp_parser_pre_parsed_nested_name_specifier (cp_parser *parser) -{ - int i; - struct tree_check *check_value; - deferred_access_check *chk; - VEC (deferred_access_check,gc) *checks; - - /* Get the stored value. */ - check_value = cp_lexer_consume_token (parser->lexer)->u.tree_check_value; - /* Perform any access checks that were deferred. */ - checks = check_value->checks; - if (checks) - { - for (i = 0 ; - VEC_iterate (deferred_access_check, checks, i, chk) ; - ++i) - { - perform_or_defer_access_check (chk->binfo, - chk->decl, - chk->diag_decl); - } - } - /* Set the scope from the stored value. */ - parser->scope = check_value->value; - parser->qualifying_scope = check_value->qualifying_scope; - parser->object_scope = NULL_TREE; -} - -/* Consume tokens up through a non-nested END token. */ - -static void -cp_parser_cache_group (cp_parser *parser, - enum cpp_ttype end, - unsigned depth) -{ - while (true) - { - cp_token *token; - - /* Abort a parenthesized expression if we encounter a brace. */ - if ((end == CPP_CLOSE_PAREN || depth == 0) - && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) - return; - /* If we've reached the end of the file, stop. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_EOF) - || (end != CPP_PRAGMA_EOL - && cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA_EOL))) - return; - /* Consume the next token. */ - token = cp_lexer_consume_token (parser->lexer); - /* See if it starts a new group. */ - if (token->type == CPP_OPEN_BRACE) - { - cp_parser_cache_group (parser, CPP_CLOSE_BRACE, depth + 1); - if (depth == 0) - return; - } - else if (token->type == CPP_OPEN_PAREN) - cp_parser_cache_group (parser, CPP_CLOSE_PAREN, depth + 1); - else if (token->type == CPP_PRAGMA) - cp_parser_cache_group (parser, CPP_PRAGMA_EOL, depth + 1); - else if (token->type == end) - return; - } -} - -/* Begin parsing tentatively. We always save tokens while parsing - tentatively so that if the tentative parsing fails we can restore the - tokens. */ - -static void -cp_parser_parse_tentatively (cp_parser* parser) -{ - /* Enter a new parsing context. */ - parser->context = cp_parser_context_new (parser->context); - /* Begin saving tokens. */ - cp_lexer_save_tokens (parser->lexer); - /* In order to avoid repetitive access control error messages, - access checks are queued up until we are no longer parsing - tentatively. */ - push_deferring_access_checks (dk_deferred); -} - -/* Commit to the currently active tentative parse. */ - -static void -cp_parser_commit_to_tentative_parse (cp_parser* parser) -{ - cp_parser_context *context; - cp_lexer *lexer; - - /* Mark all of the levels as committed. */ - lexer = parser->lexer; - for (context = parser->context; context->next; context = context->next) - { - if (context->status == CP_PARSER_STATUS_KIND_COMMITTED) - break; - context->status = CP_PARSER_STATUS_KIND_COMMITTED; - while (!cp_lexer_saving_tokens (lexer)) - lexer = lexer->next; - cp_lexer_commit_tokens (lexer); - } -} - -/* Abort the currently active tentative parse. All consumed tokens - will be rolled back, and no diagnostics will be issued. */ - -static void -cp_parser_abort_tentative_parse (cp_parser* parser) -{ - cp_parser_simulate_error (parser); - /* Now, pretend that we want to see if the construct was - successfully parsed. */ - cp_parser_parse_definitely (parser); -} - -/* Stop parsing tentatively. If a parse error has occurred, restore the - token stream. Otherwise, commit to the tokens we have consumed. - Returns true if no error occurred; false otherwise. */ - -static bool -cp_parser_parse_definitely (cp_parser* parser) -{ - bool error_occurred; - cp_parser_context *context; - - /* Remember whether or not an error occurred, since we are about to - destroy that information. */ - error_occurred = cp_parser_error_occurred (parser); - /* Remove the topmost context from the stack. */ - context = parser->context; - parser->context = context->next; - /* If no parse errors occurred, commit to the tentative parse. */ - if (!error_occurred) - { - /* Commit to the tokens read tentatively, unless that was - already done. */ - if (context->status != CP_PARSER_STATUS_KIND_COMMITTED) - cp_lexer_commit_tokens (parser->lexer); - - pop_to_parent_deferring_access_checks (); - } - /* Otherwise, if errors occurred, roll back our state so that things - are just as they were before we began the tentative parse. */ - else - { - cp_lexer_rollback_tokens (parser->lexer); - pop_deferring_access_checks (); - } - /* Add the context to the front of the free list. */ - context->next = cp_parser_context_free_list; - cp_parser_context_free_list = context; - - return !error_occurred; -} - -/* Returns true if we are parsing tentatively and are not committed to - this tentative parse. */ - -static bool -cp_parser_uncommitted_to_tentative_parse_p (cp_parser* parser) -{ - return (cp_parser_parsing_tentatively (parser) - && parser->context->status != CP_PARSER_STATUS_KIND_COMMITTED); -} - -/* Returns nonzero iff an error has occurred during the most recent - tentative parse. */ - -static bool -cp_parser_error_occurred (cp_parser* parser) -{ - return (cp_parser_parsing_tentatively (parser) - && parser->context->status == CP_PARSER_STATUS_KIND_ERROR); -} - -/* Returns nonzero if GNU extensions are allowed. */ - -static bool -cp_parser_allow_gnu_extensions_p (cp_parser* parser) -{ - return parser->allow_gnu_extensions_p; -} - -/* Objective-C++ Productions */ - -/* APPLE LOCAL begin CW asm blocks */ - -/* This is the section of CW-asm-specific parsing functions. */ - -static tree -cp_parser_iasm_compound_statement (cp_parser *parser) -{ - tree compound_stmt; - - iasm_state = iasm_asm; - inside_iasm_block = true; - iasm_kill_regs = true; - if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'")) - return error_mark_node; - /* Begin the compound-statement. */ - compound_stmt = begin_compound_stmt (/*has_no_scope=*/false); - /* Parse an (optional) statement-seq. */ - cp_parser_iasm_line_seq_opt (parser); - /* Finish the compound-statement. */ - finish_compound_stmt (compound_stmt); - /* Consume the `}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - /* We're done with the block of asm. */ - iasm_end_block (); - iasm_state = iasm_none; - return compound_stmt; -} - -static void -cp_parser_iasm_top_statement (cp_parser *parser) -{ - tree compound_stmt; - - iasm_state = iasm_asm; - inside_iasm_block = true; - iasm_kill_regs = true; - /* Begin the compound-statement. */ - compound_stmt = begin_compound_stmt (/*has_no_scope=*/false); - if (!cp_lexer_iasm_bol (parser->lexer)) - { - /* Parse a line. */ - cp_parser_iasm_line (parser); - } - /* Finish the compound-statement. */ - finish_compound_stmt (compound_stmt); - /* We're done with the block of asm. */ - iasm_end_block (); - iasm_state = iasm_none; -} - -static void -cp_parser_iasm_declaration_seq_opt (cp_parser* parser) -{ - cp_token *token = cp_lexer_peek_token (parser->lexer); - - if (token->type == CPP_NAME - && !iasm_typename_or_reserved (token->u.value)) - return; - - /* Scan declarations until there aren't any more. */ - while (true) - { - /* If we're looking at a `}', then we've run out of statements. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE) - || cp_lexer_next_token_is (parser->lexer, CPP_EOF)) - break; - - /* Parse a declaration. */ - cp_parser_simple_declaration (parser, false); - - /* CPP_PRAGMA is a #pragma inside a function body, which - constitutes a declaration all its own. */ - if (token->type == CPP_PRAGMA) - cp_parser_pragma (parser, pragma_external); - - if (iasm_state >= iasm_decls - && (cp_lexer_iasm_bol (parser->lexer) - || cp_lexer_next_token_is (parser->lexer, CPP_NAME))) - break; - } -} - -/* Parse an (optional) line-seq. - - line-seq: - line - line-seq [opt] line */ - -static void -cp_parser_iasm_line_seq_opt (cp_parser* parser) -{ - /* Scan lines of asm until there aren't any more. */ - while (true) - { - /* If we're looking at a `}', then we've run out of lines. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE) - || cp_lexer_next_token_is (parser->lexer, CPP_EOF)) - break; - - /* Parse the line. */ - cp_parser_iasm_line (parser); - } -} - -static void -cp_parser_iasm_line (cp_parser* parser) -{ - cp_parser_iasm_statement_seq_opt (parser); -} - -/* Skip tokens until the end of line is seen. */ - -static void -cp_parser_iasm_skip_to_eol (cp_parser *parser) -{ - while (true) - { - cp_token *token; - - /* Do CPP_NUMBER specially to avoid errors on things like ; 1st - when doing MS-style asms. */ - if ((token = parser->lexer->next_token)->type == CPP_NUMBER - || token->type == CPP_HASH - || token->type == CPP_PASTE - || token->type == CPP_OTHER) - ; - else - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* If we've run out of tokens, stop. */ - if (token->type == CPP_EOF) - break; - /* If the next token starts a new line, stop. */ - if (cp_lexer_iasm_bol (parser->lexer)) - break; - /* Otherwise, consume the token. */ - cp_lexer_consume_token (parser->lexer); - } -} - -static void -cp_parser_iasm_maybe_skip_comments (cp_parser *parser) -{ - if (flag_ms_asms - && cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) - { - /* Eat the ';', then skip rest of characters on this line. */ - cp_lexer_consume_token (parser->lexer); - cp_parser_iasm_skip_to_eol (parser); - } -} - -/* Parse an asm line. The first token cannot be at the beginning of - the line. */ - -static void -cp_parser_iasm_statement_seq_opt (cp_parser* parser) -{ - int check; - /* Scan statements until there aren't any more. */ - while (true) - { - check = 0; - /* Semicolons divide up individual statements. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) - { - /* ; denotes comments in MS-style asms. */ - if (flag_ms_asms) - { - cp_parser_iasm_maybe_skip_comments (parser); - return; - } - cp_lexer_consume_token (parser->lexer); - } - else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ASM)) - { - cp_lexer_consume_token (parser->lexer); - } - else - { - /* Parse a single statement. */ - cp_parser_iasm_statement (parser); - check = 1; - } - - if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE) - || cp_lexer_next_token_is (parser->lexer, CPP_EOF) - /* We parse at most, one line. */ - || cp_lexer_iasm_bol (parser->lexer)) - return; - - if (check - && !(cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE) - || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON) - || cp_lexer_next_token_is_keyword (parser->lexer, RID_ASM) - || cp_lexer_iasm_bol (parser->lexer))) - { - cp_parser_error (parser, "expected `;' or `}' `asm' or end-of-line"); - } - } - if (!cp_lexer_iasm_bol (parser->lexer)) - cp_parser_iasm_maybe_skip_comments (parser); -} - -/* Build an identifier comprising the string passed and the - next token. */ - -static tree -iasm_build_identifier_string (cp_parser* parser, const char* str) -{ - char *buf; - int len; - tree id; - - if (strcmp (str, ".") == 0 - && (cp_lexer_peek_token (parser->lexer)->flags & PREV_WHITE) == 0) - { - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_SHORT)) - { - cp_lexer_consume_token (parser->lexer); - return get_identifier (".short"); - } - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_LONG)) - { - cp_lexer_consume_token (parser->lexer); - return get_identifier (".long"); - } - } - - id = cp_parser_iasm_identifier_or_number (parser); - len = strlen (str); - buf = (char *) alloca (IDENTIFIER_LENGTH (id) + len + 1); - memcpy (buf, str, len); - memcpy (buf+len, IDENTIFIER_POINTER (id), IDENTIFIER_LENGTH (id)); - buf[IDENTIFIER_LENGTH (id) + len] = 0; - return get_identifier (buf); -} - -/* Parse a CW asm identifier. Returns an IDENTIFIER_NODE representing - the identifier. The CW asm identifieriers include [.+-] as part of - the identifier. */ - -static tree -cp_parser_iasm_identifier (cp_parser* parser) -{ - cp_token *token; - tree t; - const char *str = ""; - - /* We have to accept certain keywords. */ - token = cp_lexer_peek_token (parser->lexer); - if (token->flags & NAMED_OP) - { - const char *s = 0; - switch (token->type) { - case CPP_AND_AND: s="and"; break; - case CPP_AND_EQ: s="and_eq"; break; - case CPP_AND: s="bitand"; break; - case CPP_OR: s="bitor"; break; - case CPP_COMPL: s="compl"; break; - case CPP_NOT: s="not"; break; - case CPP_NOT_EQ: s="not_eq"; break; - case CPP_OR_OR: s="or"; break; - case CPP_OR_EQ: s="or_eq"; break; - case CPP_XOR: s="xor"; break; - case CPP_XOR_EQ: s="xor_eq"; break; - default: break; - } - - /* The above list is the entire list of named operators. We - can't fail to translate the name. See operator_array in - libcpp/init.c. */ - gcc_assert (s != 0); - cp_lexer_consume_token (parser->lexer); - t = get_identifier (s); - } - else if (token->type == CPP_DOT) - { - /* .align */ - cp_lexer_consume_token (parser->lexer); - t = iasm_build_identifier_string (parser, "."); - } - else if (token->u.value - && IASM_SEE_OPCODE (TYPESPEC, token->u.value) == IDENTIFIER) - { - cp_lexer_consume_token (parser->lexer); - t = token->u.value; - } - else - t = cp_parser_identifier (parser); - - if (t == error_mark_node) - return t; - - token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_DOT: - str = "."; - break; - case CPP_PLUS: - str = "+"; - break; - case CPP_MINUS: - str = "-"; - break; - case CPP_PLUS_PLUS: - str = "++"; - break; - case CPP_MINUS_MINUS: - str = "--"; - break; - default: - return t; - } - - /* If there was whitespace between the identifier and the [.+-] - character, then that character can't be part of the - identifier. */ - if (token->flags & PREV_WHITE) - return t; - - cp_lexer_consume_token (parser->lexer); - - return iasm_get_identifier (t, str); -} - -static tree -cp_parser_iasm_identifier_or_number (cp_parser* parser) -{ - cp_token *token; - - token = cp_lexer_peek_token (parser->lexer); - if (token->type == CPP_NUMBER - && TREE_CODE (token->u.value) == INTEGER_CST) - { - char buf[60]; - - sprintf (buf, HOST_WIDE_INT_PRINT_UNSIGNED, tree_low_cst (token->u.value, 0)); - cp_lexer_consume_token (parser->lexer); - return get_identifier (buf); - } - - return cp_parser_identifier (parser); -} - -static tree -cp_parser_iasm_maybe_prefix (cp_parser *parser, tree id) -{ - tree prefix_list = NULL_TREE; - - while (iasm_is_prefix (id)) - { - if (cp_lexer_iasm_bol (parser->lexer)) - break; - prefix_list = tree_cons (NULL_TREE, id, prefix_list); - id = cp_parser_iasm_identifier (parser); - } - - if (prefix_list) - id = tree_cons (NULL_TREE, id, prefix_list); - return id; -} - -/* A single statement consists of one or more labels (identified by a - leading '@' and/or a trailing ':'), optionally followed by opcode - and operands. */ - -static void -cp_parser_iasm_statement (cp_parser* parser) -{ - tree aname, anothername, operands; - - /* Keep sucking labels from the front of the statement until a - non-label is seen. */ - while (true) - { - if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON) - || cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE) - || cp_lexer_next_token_is (parser->lexer, CPP_EOF)) - break; - - if (cp_lexer_next_token_is (parser->lexer, CPP_PRAGMA)) - { - cp_parser_pragma (parser, pragma_compound); - } - else if (cp_lexer_next_token_is (parser->lexer, CPP_ATSIGN)) - { - cp_lexer_consume_token (parser->lexer); - aname = cp_parser_iasm_identifier_or_number (parser); - /* Optional ':' after a label. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COLON)) - cp_lexer_consume_token (parser->lexer); - iasm_label (aname, true); - } - else - { - aname = cp_parser_iasm_identifier (parser); - if (cp_lexer_next_token_is (parser->lexer, CPP_COLON)) - { - cp_lexer_consume_token (parser->lexer); - iasm_label (aname, false); - } - else - { - enum rid scspec = RID_EXTERN; - - if (strcmp (IDENTIFIER_POINTER (aname), "entry") == 0) - { - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC) - || cp_lexer_next_token_is_keyword (parser->lexer, RID_EXTERN)) - scspec = cp_lexer_consume_token (parser->lexer)->keyword; - anothername = cp_parser_iasm_operand (parser); - iasm_entry (scspec, anothername); - } - else - { - aname = cp_parser_iasm_maybe_prefix (parser, aname); - iasm_in_operands = true; - operands = cp_parser_iasm_operands (parser); - iasm_stmt (aname, operands, input_line); - } - if (cp_lexer_iasm_bol (parser->lexer)) - return; - break; - } - } - - if (cp_lexer_iasm_bol (parser->lexer)) - return; - } - cp_parser_iasm_maybe_skip_comments (parser); -} - -/* Eat tokens until we get back to something we recognize. */ - -static void -cp_parser_iasm_skip_to_next_asm (cp_parser *parser) -{ - cp_token *token = cp_lexer_peek_token (parser->lexer); - do - { - if (cp_lexer_iasm_bol (parser->lexer) - || token->type == CPP_SEMICOLON - || token->type == CPP_CLOSE_BRACE - || token->type == CPP_EOF - || token->keyword == RID_ASM) - return; - cp_lexer_consume_token (parser->lexer); - } - while (1); -} - -static tree -cp_parser_iasm_operands (cp_parser *parser) -{ - tree operands = NULL_TREE, operand; - - while (true) - { - /* If we're looking at the end of the line, then we've run out of operands. */ - if (cp_lexer_iasm_bol (parser->lexer) - || cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON) - || cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE) - || cp_lexer_next_token_is (parser->lexer, CPP_EOF) - || cp_lexer_next_token_is_keyword (parser->lexer, RID_ASM)) - break; - - operand = cp_parser_iasm_operand (parser); - - if (operand && operand != error_mark_node) - { - operands = chainon (operands, build_tree_list (NULL_TREE, operand)); - if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) - cp_lexer_consume_token (parser->lexer); - } - else - { - cp_parser_iasm_skip_to_next_asm (parser); - return NULL_TREE; - } - } - - return operands; -} - -static tree -cp_parser_iasm_operand (cp_parser *parser) -{ - tree operand; - - /* Jump into the usual operand precedence stack. */ - operand = cp_parser_binary_expression (parser, false); - - /* Maybe this should go up higher. */ - if (BASELINK_P (operand) - && TREE_CODE (BASELINK_FUNCTIONS (operand)) == FUNCTION_DECL) - { - operand = BASELINK_FUNCTIONS (operand); - } - - return operand; -} - -/* Need to handle case of relative branch using: .[+|-]number - syntax */ -static tree -cp_parser_iasm_relative_branch (cp_parser *parser) -{ - cp_token *token; - token = cp_lexer_peek_nth_token (parser->lexer, 2); - if (token->type == CPP_PLUS || token->type == CPP_MINUS) - { - const char *str = (token->type == CPP_PLUS) ? ".+" : ".-"; - /* consume '.' */ - cp_lexer_consume_token (parser->lexer); - /* consume '-' or '+' */ - cp_lexer_consume_token (parser->lexer); - return iasm_build_identifier_string (parser, str); - } - return error_mark_node; -} - -/* Parse a CW asm-style postfix-expression. - - postfix-expression: - primary-expression - postfix-expression [ expression ] - postfix-expression ( expression-list [opt] ) - simple-type-specifier ( expression-list [opt] ) - postfix-expression . template [opt] id-expression - postfix-expression -> template [opt] id-expression - postfix-expression . pseudo-destructor-name - postfix-expression -> pseudo-destructor-name - typeid ( expression ) - typeid ( type-id ) - - GNU Extension: - - postfix-expression: - ( type-id ) { initializer-list , [opt] } - - This extension is a GNU version of the C99 compound-literal - construct. (The C99 grammar uses `type-name' instead of `type-id', - but they are essentially the same concept.) - - If ADDRESS_P is true, the postfix expression is the operand of the - `&' operator. CAST_P is true if this expression is the target of a - cast. - - Returns a representation of the expression. */ - -static tree -cp_parser_iasm_postfix_expression (cp_parser *parser, bool address_p, bool cast_p) -{ - bool for_offsetof = false; - cp_token *token; - enum rid keyword; - cp_id_kind idk = CP_ID_KIND_NONE; - tree postfix_expression = NULL_TREE; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - /* Some of the productions are determined by keywords. */ - keyword = token->keyword; - switch (keyword) - { - case RID_SIZEOF: - { - tree operand; - /* Consume the token. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the operand. */ - operand = cp_parser_sizeof_operand (parser, keyword); - postfix_expression = cxx_sizeof_or_alignof_type (operand, SIZEOF_EXPR, true); - break; - } - - default: - { - tree type; - - /* If the next thing is a simple-type-specifier, we may be - looking at a functional cast. We could also be looking at - an id-expression. So, we try the functional cast, and if - that doesn't work we fall back to the primary-expression. */ - cp_parser_parse_tentatively (parser); - /* Look for the simple-type-specifier. */ - type = cp_parser_simple_type_specifier (parser, - CP_PARSER_FLAGS_NONE, - /*identifier_p=*/false); - /* Parse the cast itself. */ - if (!cp_parser_error_occurred (parser)) - postfix_expression - = cp_parser_functional_cast (parser, type); - /* If that worked, we're done. */ - if (cp_parser_parse_definitely (parser)) - break; - - if (token->type == CPP_DOT || token->type == CPP_MULT) - { - postfix_expression = cp_parser_iasm_relative_branch (parser); - if (postfix_expression != error_mark_node) - break; - } - - /* If the functional-cast didn't work out, try a - compound-literal. */ - if (cp_parser_allow_gnu_extensions_p (parser) - && cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - { - VEC(constructor_elt,gc) *initializer_list = NULL; - bool saved_in_type_id_in_expr_p; - - cp_parser_parse_tentatively (parser); - /* Consume the `('. */ - cp_lexer_consume_token (parser->lexer); - /* Parse the type. */ - saved_in_type_id_in_expr_p = parser->in_type_id_in_expr_p; - parser->in_type_id_in_expr_p = true; - type = cp_parser_type_id (parser); - parser->in_type_id_in_expr_p = saved_in_type_id_in_expr_p; - /* Look for the `)'. */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - /* Look for the `{'. */ - cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"); - /* If things aren't going well, there's no need to - keep going. */ - if (!cp_parser_error_occurred (parser)) - { - bool non_constant_p; - /* Parse the initializer-list. */ - initializer_list - = cp_parser_initializer_list (parser, &non_constant_p); - /* Allow a trailing `,'. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) - cp_lexer_consume_token (parser->lexer); - /* Look for the final `}'. */ - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - } - /* If that worked, we're definitely looking at a - compound-literal expression. */ - if (cp_parser_parse_definitely (parser)) - { - /* Warn the user that a compound literal is not - allowed in standard C++. */ - if (pedantic) - pedwarn ("ISO C++ forbids compound-literals"); - /* Form the representation of the compound-literal. */ - postfix_expression - = finish_compound_literal (type, initializer_list); - break; - } - } - - /* It must be a primary-expression. */ - postfix_expression = cp_parser_primary_expression (parser, address_p, cast_p, - /*template_arg_p=*/false, - &idk); - } - break; - } - - /* Keep looping until the postfix-expression is complete. */ - while (true) - { - if (idk == CP_ID_KIND_UNQUALIFIED - && TREE_CODE (postfix_expression) == IDENTIFIER_NODE - && cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_PAREN)) - /* It is not a Koenig lookup function call. */ - postfix_expression - = unqualified_name_lookup_error (postfix_expression); - - if (cp_lexer_iasm_bol (parser->lexer)) - return postfix_expression; - - /* Peek at the next token. */ - token = cp_lexer_peek_token (parser->lexer); - - switch (token->type) - { - case CPP_OPEN_SQUARE: - postfix_expression - = cp_parser_postfix_open_square_expression (parser, - postfix_expression, - false); - idk = CP_ID_KIND_NONE; - break; - - case CPP_OPEN_PAREN: - /* postfix-expression ( expression ) */ - { - tree expr; - - cp_lexer_consume_token (parser->lexer); - expr = cp_parser_binary_expression (parser, false); - - if (expr == error_mark_node) - { - postfix_expression = error_mark_node; - break; - } - - postfix_expression = - iasm_build_register_offset (postfix_expression, expr); - - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - /* The POSTFIX_EXPRESSION is certainly no longer an id. */ - idk = CP_ID_KIND_NONE; - } - break; - - case CPP_DOT: - case CPP_DEREF: - /* postfix-expression . template [opt] id-expression - postfix-expression . pseudo-destructor-name - postfix-expression -> template [opt] id-expression - postfix-expression -> pseudo-destructor-name */ - { - tree name; - bool dependent_p; - bool template_p; - tree scope = NULL_TREE; - enum cpp_ttype token_type = token->type; - - /* We allow [eax].16 to refer to [eax + 16]. */ - if (TREE_CODE (postfix_expression) == BRACKET_EXPR) - { - cp_token *new_token; - - new_token = cp_lexer_peek_nth_token (parser->lexer, 2); - if (new_token->type == CPP_NUMBER) - { - /* Consume the `.' or `->' operator. */ - cp_lexer_consume_token (parser->lexer); - postfix_expression = iasm_build_bracket (postfix_expression, - new_token->u.value); - cp_lexer_consume_token (parser->lexer); - break; - } - } - - /* If this is a `->' operator, dereference the pointer. */ - if (token->type == CPP_DEREF) - postfix_expression = build_x_arrow (postfix_expression); - /* Check to see whether or not the expression is - type-dependent. */ - dependent_p = type_dependent_expression_p (postfix_expression); - /* The identifier following the `->' or `.' is not - qualified. */ - parser->scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - idk = CP_ID_KIND_NONE; - /* Enter the scope corresponding to the type of the object - given by the POSTFIX_EXPRESSION. */ - if (!dependent_p - && TREE_TYPE (postfix_expression) != NULL_TREE) - { - scope = TREE_TYPE (postfix_expression); - /* According to the standard, no expression should - ever have reference type. Unfortunately, we do not - currently match the standard in this respect in - that our internal representation of an expression - may have reference type even when the standard says - it does not. Therefore, we have to manually obtain - the underlying type here. */ - scope = non_reference (scope); - /* The type of the POSTFIX_EXPRESSION must be - complete. */ - scope = complete_type_or_else (scope, NULL_TREE); - /* Let the name lookup machinery know that we are - processing a class member access expression. */ - parser->context->object_type = scope; - /* If something went wrong, we want to be able to - discern that case, as opposed to the case where - there was no SCOPE due to the type of expression - being dependent. */ - if (!scope) - scope = error_mark_node; - /* If the SCOPE was erroneous, make the various - semantic analysis functions exit quickly -- and - without issuing additional error messages. */ - if (scope == error_mark_node) - postfix_expression = error_mark_node; - } - - /* Consume the `.' or `->' operator. */ - cp_lexer_consume_token (parser->lexer); - /* If the SCOPE is not a scalar type, we are looking at an - ordinary class member access expression, rather than a - pseudo-destructor-name. */ - if (!scope || !SCALAR_TYPE_P (scope)) - { - template_p = cp_parser_optional_template_keyword (parser); - /* Parse the id-expression. */ - name = cp_parser_id_expression (parser, - template_p, - /*check_dependency_p=*/true, - /*template_p=*/NULL, - /*declarator_p=*/false, - /*optional_p=*/false); - /* In general, build a SCOPE_REF if the member name is - qualified. However, if the name was not dependent - and has already been resolved; there is no need to - build the SCOPE_REF. For example; - - struct X { void f(); }; - template <typename T> void f(T* t) { t->X::f(); } - - Even though "t" is dependent, "X::f" is not and has - been resolved to a BASELINK; there is no need to - include scope information. */ - - /* But we do need to remember that there was an explicit - scope for virtual function calls. */ - if (parser->scope) - idk = CP_ID_KIND_QUALIFIED; - - if (name != error_mark_node - && !BASELINK_P (name) - && parser->scope) - { - name = build_nt (SCOPE_REF, parser->scope, name); - parser->scope = NULL_TREE; - parser->qualifying_scope = NULL_TREE; - parser->object_scope = NULL_TREE; - } - if (scope && name && BASELINK_P (name)) - adjust_result_of_qualified_name_lookup - (name, BINFO_TYPE (BASELINK_BINFO (name)), scope); - postfix_expression - = iasm_cp_build_component_ref (postfix_expression, name); - } - /* Otherwise, try the pseudo-destructor-name production. */ - else - { - tree s = NULL_TREE; - tree type; - - /* Parse the pseudo-destructor-name. */ - cp_parser_pseudo_destructor_name (parser, &s, &type); - /* Form the call. */ - postfix_expression - = finish_pseudo_destructor_expr (postfix_expression, - s, TREE_TYPE (type)); - } - - /* We no longer need to look up names in the scope of the - object on the left-hand side of the `.' or `->' - operator. */ - parser->context->object_type = NULL_TREE; - - /* Outside of offsetof, these operators may not appear in - constant-expressions. */ - if (!for_offsetof - && (cp_parser_non_integral_constant_expression - (parser, token_type == CPP_DEREF ? "'->'" : "`.'"))) - postfix_expression = error_mark_node; - } - break; - - case CPP_NAME: - if (strcasecmp (IDENTIFIER_POINTER (token->u.value), "ptr") == 0) - { - /* Handle things like: inc dword ptr [eax] */ - tree type = postfix_expression; - cp_lexer_consume_token (parser->lexer); - postfix_expression = cp_parser_iasm_postfix_expression (parser, address_p, cast_p); - postfix_expression = iasm_ptr_conv (type, postfix_expression); - } - - default: - return postfix_expression; - } - } - - /* We should never get here. */ - abort (); - return error_mark_node; -} - -int -iasm_typename_or_reserved (tree value) -{ - tree type_decl; - - if (IASM_SEE_OPCODE (TYPESPEC, value) == IDENTIFIER) - return 0; - - if (C_IS_RESERVED_WORD (value)) - return 1; - - type_decl = lookup_name_real (value, 0, 0, true, 0, 0); - return type_decl - && (TREE_CODE (type_decl) == TYPE_DECL - || TREE_CODE (type_decl) == NAMESPACE_DECL - || TREE_CODE (type_decl) == TEMPLATE_DECL); -} -/* APPLE LOCAL end CW asm blocks */ - -/* Parse an Objective-C expression, which feeds into a primary-expression - above. - - objc-expression: - objc-message-expression - objc-string-literal - objc-encode-expression - objc-protocol-expression - objc-selector-expression - - Returns a tree representation of the expression. */ - -static tree -cp_parser_objc_expression (cp_parser* parser) -{ - /* Try to figure out what kind of declaration is present. */ - cp_token *kwd = cp_lexer_peek_token (parser->lexer); - - switch (kwd->type) - { - case CPP_OPEN_SQUARE: - return cp_parser_objc_message_expression (parser); - - case CPP_OBJC_STRING: - kwd = cp_lexer_consume_token (parser->lexer); - return objc_build_string_object (kwd->u.value); - - case CPP_KEYWORD: - switch (kwd->keyword) - { - case RID_AT_ENCODE: - return cp_parser_objc_encode_expression (parser); - - case RID_AT_PROTOCOL: - return cp_parser_objc_protocol_expression (parser); - - case RID_AT_SELECTOR: - return cp_parser_objc_selector_expression (parser); - - default: - break; - } - default: - error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value); - cp_parser_skip_to_end_of_block_or_statement (parser); - } - - return error_mark_node; -} - -/* Parse an Objective-C message expression. - - objc-message-expression: - [ objc-message-receiver objc-message-args ] - - Returns a representation of an Objective-C message. */ - -static tree -cp_parser_objc_message_expression (cp_parser* parser) -{ - tree receiver, messageargs; - - cp_lexer_consume_token (parser->lexer); /* Eat '['. */ - receiver = cp_parser_objc_message_receiver (parser); - messageargs = cp_parser_objc_message_args (parser); - cp_parser_require (parser, CPP_CLOSE_SQUARE, "`]'"); - - return objc_build_message_expr (build_tree_list (receiver, messageargs)); -} - -/* APPLE LOCAL begin radar 5277239 */ -/* Parse an Objective-C dot-syntax class expression. - - objc-message-expression: - class-name '.' class-method-name - - Returns an objc_property_reference expression. */ - -static tree -cp_parser_objc_reference_expression (cp_parser* parser, tree type_decl) -{ - tree receiver, component; - receiver = objc_get_class_reference (TREE_TYPE (type_decl)); - cp_lexer_consume_token (parser->lexer); /* Eact '.' */ - component = cp_parser_objc_message_args (parser); - return objc_build_property_reference_expr (receiver, TREE_PURPOSE (component)); -} -/* APPLE LOCAL end radar 5277239 */ -/* Parse an objc-message-receiver. - - objc-message-receiver: - expression - simple-type-specifier - - Returns a representation of the type or expression. */ - -static tree -cp_parser_objc_message_receiver (cp_parser* parser) -{ - tree rcv; - - /* An Objective-C message receiver may be either (1) a type - or (2) an expression. */ - cp_parser_parse_tentatively (parser); - rcv = cp_parser_expression (parser, false); - - if (cp_parser_parse_definitely (parser)) - return rcv; - - rcv = cp_parser_simple_type_specifier (parser, - /*decl_specs=*/NULL, - CP_PARSER_FLAGS_NONE); - - return objc_get_class_reference (rcv); -} - -/* Parse the arguments and selectors comprising an Objective-C message. - - objc-message-args: - objc-selector - objc-selector-args - objc-selector-args , objc-comma-args - - objc-selector-args: - objc-selector [opt] : assignment-expression - objc-selector-args objc-selector [opt] : assignment-expression - - objc-comma-args: - assignment-expression - objc-comma-args , assignment-expression - - Returns a TREE_LIST, with TREE_PURPOSE containing a list of - selector arguments and TREE_VALUE containing a list of comma - arguments. */ - -static tree -cp_parser_objc_message_args (cp_parser* parser) -{ - tree sel_args = NULL_TREE, addl_args = NULL_TREE; - bool maybe_unary_selector_p = true; - cp_token *token = cp_lexer_peek_token (parser->lexer); - - while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON) - { - tree selector = NULL_TREE, arg; - - if (token->type != CPP_COLON) - selector = cp_parser_objc_selector (parser); - - /* Detect if we have a unary selector. */ - if (maybe_unary_selector_p - && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)) - return build_tree_list (selector, NULL_TREE); - - maybe_unary_selector_p = false; - cp_parser_require (parser, CPP_COLON, "`:'"); - arg = cp_parser_assignment_expression (parser, false); - - sel_args - = chainon (sel_args, - build_tree_list (selector, arg)); - - token = cp_lexer_peek_token (parser->lexer); - } - - /* Handle non-selector arguments, if any. */ - while (token->type == CPP_COMMA) - { - tree arg; - - cp_lexer_consume_token (parser->lexer); - arg = cp_parser_assignment_expression (parser, false); - - addl_args - = chainon (addl_args, - build_tree_list (NULL_TREE, arg)); - - token = cp_lexer_peek_token (parser->lexer); - } - /* APPLE LOCAL begin radar 4294425 */ - if (sel_args == NULL_TREE && addl_args == NULL_TREE) - { - cp_parser_error (parser, "objective-c++ message argument(s) are expected"); - return build_tree_list (error_mark_node, error_mark_node); - } - /* APPLE LOCAL end radar 4294425 */ - return build_tree_list (sel_args, addl_args); -} - -/* Parse an Objective-C encode expression. - - objc-encode-expression: - @encode objc-typename - - Returns an encoded representation of the type argument. */ - -static tree -cp_parser_objc_encode_expression (cp_parser* parser) -{ - tree type; - - cp_lexer_consume_token (parser->lexer); /* Eat '@encode'. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - type = complete_type (cp_parser_type_id (parser)); - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - if (!type) - { - error ("%<@encode%> must specify a type as an argument"); - return error_mark_node; - } - - /* APPLE LOCAL begin radar 4278774 */ - if (dependent_type_p (type)) - { - tree value = build_min (AT_ENCODE_EXPR, size_type_node, type); - TREE_READONLY (value) = 1; - return value; - } - /* APPLE LOCAL end radar 4278774 */ - - return objc_build_encode_expr (type); -} - -/* Parse an Objective-C @defs expression. */ - -static tree -cp_parser_objc_defs_expression (cp_parser *parser) -{ - tree name; - - cp_lexer_consume_token (parser->lexer); /* Eat '@defs'. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - name = cp_parser_identifier (parser); - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - return objc_get_class_ivars (name); -} - -/* Parse an Objective-C protocol expression. - - objc-protocol-expression: - @protocol ( identifier ) - - Returns a representation of the protocol expression. */ - -static tree -cp_parser_objc_protocol_expression (cp_parser* parser) -{ - tree proto; - - cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - proto = cp_parser_identifier (parser); - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - return objc_build_protocol_expr (proto); -} - -/* Parse an Objective-C selector expression. - - objc-selector-expression: - @selector ( objc-method-signature ) - - objc-method-signature: - objc-selector - objc-selector-seq - - objc-selector-seq: - objc-selector : - objc-selector-seq objc-selector : - - Returns a representation of the method selector. */ - -static tree -cp_parser_objc_selector_expression (cp_parser* parser) -{ - tree sel_seq = NULL_TREE; - bool maybe_unary_selector_p = true; - cp_token *token; - - cp_lexer_consume_token (parser->lexer); /* Eat '@selector'. */ - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - token = cp_lexer_peek_token (parser->lexer); - - while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON - || token->type == CPP_SCOPE) - { - tree selector = NULL_TREE; - - if (token->type != CPP_COLON - || token->type == CPP_SCOPE) - selector = cp_parser_objc_selector (parser); - - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON) - && cp_lexer_next_token_is_not (parser->lexer, CPP_SCOPE)) - { - /* Detect if we have a unary selector. */ - if (maybe_unary_selector_p) - { - sel_seq = selector; - goto finish_selector; - } - else - { - cp_parser_error (parser, "expected %<:%>"); - } - } - maybe_unary_selector_p = false; - token = cp_lexer_consume_token (parser->lexer); - - if (token->type == CPP_SCOPE) - { - sel_seq - = chainon (sel_seq, - build_tree_list (selector, NULL_TREE)); - sel_seq - = chainon (sel_seq, - build_tree_list (NULL_TREE, NULL_TREE)); - } - else - sel_seq - = chainon (sel_seq, - build_tree_list (selector, NULL_TREE)); - - token = cp_lexer_peek_token (parser->lexer); - } - - finish_selector: - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - return objc_build_selector_expr (sel_seq); -} - -/* Parse a list of identifiers. - - objc-identifier-list: - identifier - objc-identifier-list , identifier - - Returns a TREE_LIST of identifier nodes. */ - -static tree -cp_parser_objc_identifier_list (cp_parser* parser) -{ - tree list = build_tree_list (NULL_TREE, cp_parser_identifier (parser)); - cp_token *sep = cp_lexer_peek_token (parser->lexer); - - while (sep->type == CPP_COMMA) - { - cp_lexer_consume_token (parser->lexer); /* Eat ','. */ - list = chainon (list, - build_tree_list (NULL_TREE, - cp_parser_identifier (parser))); - sep = cp_lexer_peek_token (parser->lexer); - } - - return list; -} - -/* Parse an Objective-C alias declaration. - - objc-alias-declaration: - @compatibility_alias identifier identifier ; - - This function registers the alias mapping with the Objective-C front-end. - It returns nothing. */ - -static void -cp_parser_objc_alias_declaration (cp_parser* parser) -{ - tree alias, orig; - - cp_lexer_consume_token (parser->lexer); /* Eat '@compatibility_alias'. */ - alias = cp_parser_identifier (parser); - orig = cp_parser_identifier (parser); - objc_declare_alias (alias, orig); - cp_parser_consume_semicolon_at_end_of_statement (parser); -} - -/* Parse an Objective-C class forward-declaration. - - objc-class-declaration: - @class objc-identifier-list ; - - The function registers the forward declarations with the Objective-C - front-end. It returns nothing. */ - -static void -cp_parser_objc_class_declaration (cp_parser* parser) -{ - cp_lexer_consume_token (parser->lexer); /* Eat '@class'. */ - objc_declare_class (cp_parser_objc_identifier_list (parser)); - cp_parser_consume_semicolon_at_end_of_statement (parser); -} - -/* Parse a list of Objective-C protocol references. - - objc-protocol-refs-opt: - objc-protocol-refs [opt] - - objc-protocol-refs: - < objc-identifier-list > - - Returns a TREE_LIST of identifiers, if any. */ - -static tree -cp_parser_objc_protocol_refs_opt (cp_parser* parser) -{ - tree protorefs = NULL_TREE; - - if(cp_lexer_next_token_is (parser->lexer, CPP_LESS)) - { - cp_lexer_consume_token (parser->lexer); /* Eat '<'. */ - protorefs = cp_parser_objc_identifier_list (parser); - cp_parser_require (parser, CPP_GREATER, "`>'"); - } - - return protorefs; -} - -/* APPLE LOCAL begin radar 5355344 */ -/* This routine also parses a list of Objective-C protocol references; except that - if list is not valid, it returns FALSE and back-tracks parsing. */ - -static bool -cp_parser_objc_tentative_protocol_refs_opt (cp_parser* parser, tree *protorefs) -{ - *protorefs = NULL_TREE; - if(cp_lexer_next_token_is (parser->lexer, CPP_LESS)) - { - cp_parser_parse_tentatively (parser); - cp_lexer_consume_token (parser->lexer); /* Eat '<'. */ - *protorefs = cp_parser_objc_identifier_list (parser); - if (!cp_objc_protocol_id_list (*protorefs)) - { - cp_parser_abort_tentative_parse (parser); - return false; - } - if (cp_parser_parse_definitely (parser)) - cp_parser_require (parser, CPP_GREATER, "`>'"); - } - - return true; -} -/* APPLE LOCAL end radar 5355344 */ - -/* Parse a Objective-C visibility specification. */ - -static void -cp_parser_objc_visibility_spec (cp_parser* parser) -{ - cp_token *vis = cp_lexer_peek_token (parser->lexer); - - switch (vis->keyword) - { - case RID_AT_PRIVATE: - objc_set_visibility (2); - break; - case RID_AT_PROTECTED: - objc_set_visibility (0); - break; - case RID_AT_PUBLIC: - objc_set_visibility (1); - break; - /* APPLE LOCAL begin radar 4564694 */ - case RID_AT_PACKAGE: - objc_set_visibility (3); - break; - /* APPLE LOCAL end radar 4564694 */ - default: - return; - } - - /* Eat '@private'/'@protected'/'@public'. */ - cp_lexer_consume_token (parser->lexer); -} - -/* Parse an Objective-C method type. */ - -static void -cp_parser_objc_method_type (cp_parser* parser) -{ - objc_set_method_type - (cp_lexer_consume_token (parser->lexer)->type == CPP_PLUS - ? PLUS_EXPR - : MINUS_EXPR); -} - -/* Parse an Objective-C protocol qualifier. */ - -static tree -cp_parser_objc_protocol_qualifiers (cp_parser* parser) -{ - tree quals = NULL_TREE, node; - cp_token *token = cp_lexer_peek_token (parser->lexer); - - node = token->u.value; - - while (node && TREE_CODE (node) == IDENTIFIER_NODE - && (node == ridpointers [(int) RID_IN] - || node == ridpointers [(int) RID_OUT] - || node == ridpointers [(int) RID_INOUT] - || node == ridpointers [(int) RID_BYCOPY] - || node == ridpointers [(int) RID_BYREF] - || node == ridpointers [(int) RID_ONEWAY])) - { - quals = tree_cons (NULL_TREE, node, quals); - cp_lexer_consume_token (parser->lexer); - token = cp_lexer_peek_token (parser->lexer); - node = token->u.value; - } - - return quals; -} - -/* Parse an Objective-C typename. */ - -static tree -cp_parser_objc_typename (cp_parser* parser) -{ - tree typename = NULL_TREE; - - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - { - tree proto_quals, cp_type = NULL_TREE; - - cp_lexer_consume_token (parser->lexer); /* Eat '('. */ - proto_quals = cp_parser_objc_protocol_qualifiers (parser); - - /* An ObjC type name may consist of just protocol qualifiers, in which - case the type shall default to 'id'. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)) - cp_type = cp_parser_type_id (parser); - - /* APPLE LOCAL begin radar 6261630 */ - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_ATTRIBUTE)) - { - /* Chain on the trailing attribute. */ - tree attrs = chainon (NULL_TREE, - cp_parser_attributes_opt (parser)); - cplus_decl_attributes (&cp_type, attrs, 0); - } - /* APPLE LOCAL end radar 6261630 */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - typename = build_tree_list (proto_quals, cp_type); - } - - return typename; -} - -/* Check to see if TYPE refers to an Objective-C selector name. */ - -static bool -cp_parser_objc_selector_p (enum cpp_ttype type) -{ - return (type == CPP_NAME || type == CPP_KEYWORD - || type == CPP_AND_AND || type == CPP_AND_EQ || type == CPP_AND - || type == CPP_OR || type == CPP_COMPL || type == CPP_NOT - || type == CPP_NOT_EQ || type == CPP_OR_OR || type == CPP_OR_EQ - || type == CPP_XOR || type == CPP_XOR_EQ); -} - -/* Parse an Objective-C selector. */ - -static tree -cp_parser_objc_selector (cp_parser* parser) -{ - cp_token *token = cp_lexer_consume_token (parser->lexer); - - if (!cp_parser_objc_selector_p (token->type)) - { - error ("invalid Objective-C++ selector name"); - return error_mark_node; - } - - /* C++ operator names are allowed to appear in ObjC selectors. */ - switch (token->type) - { - case CPP_AND_AND: return get_identifier ("and"); - case CPP_AND_EQ: return get_identifier ("and_eq"); - case CPP_AND: return get_identifier ("bitand"); - case CPP_OR: return get_identifier ("bitor"); - case CPP_COMPL: return get_identifier ("compl"); - case CPP_NOT: return get_identifier ("not"); - case CPP_NOT_EQ: return get_identifier ("not_eq"); - case CPP_OR_OR: return get_identifier ("or"); - case CPP_OR_EQ: return get_identifier ("or_eq"); - case CPP_XOR: return get_identifier ("xor"); - case CPP_XOR_EQ: return get_identifier ("xor_eq"); - default: return token->u.value; - } -} - -/* APPLE LOCAL begin radar 3803157 - objc attribute */ -static void -cp_parser_objc_maybe_attributes (cp_parser* parser, tree* attributes) -{ - cp_token *token = cp_lexer_peek_token (parser->lexer); - if (*attributes != NULL_TREE) - { - error ("method attributes must be specified at the end only"); - *attributes = NULL_TREE; - } - if (token->keyword == RID_ATTRIBUTE) - *attributes = cp_parser_attributes_opt (parser); -} - -/* Parse an Objective-C params list. */ - -static tree -cp_parser_objc_method_keyword_params (cp_parser* parser, tree* attributes) -/* APPLE LOCAL end radar 3803157 - objc attribute */ -{ - tree params = NULL_TREE; - bool maybe_unary_selector_p = true; - cp_token *token = cp_lexer_peek_token (parser->lexer); - - while (cp_parser_objc_selector_p (token->type) || token->type == CPP_COLON) - { - tree selector = NULL_TREE, typename, identifier; - /* APPLE LOCAL radar 4157812 */ - tree attr = NULL_TREE; - - if (token->type != CPP_COLON) - selector = cp_parser_objc_selector (parser); - - /* Detect if we have a unary selector. */ - if (maybe_unary_selector_p - && cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)) - /* APPLE LOCAL begin radar 3803157 - objc attribute */ - { - cp_parser_objc_maybe_attributes (parser, attributes); - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COLON)) - return selector; - } - /* APPLE LOCAL end radar 3803157 - objc attribute */ - - maybe_unary_selector_p = false; - cp_parser_require (parser, CPP_COLON, "`:'"); - typename = cp_parser_objc_typename (parser); - /* APPLE LOCAL radar 4157812 */ - cp_parser_objc_maybe_attributes (parser, &attr); - identifier = cp_parser_identifier (parser); - /* APPLE LOCAL radar 3803157 - objc attribute */ - cp_parser_objc_maybe_attributes (parser, attributes); - - params - = chainon (params, - objc_build_keyword_decl (selector, - typename, - /* APPLE LOCAL radar 4157812 */ - identifier, attr)); - - token = cp_lexer_peek_token (parser->lexer); - } - - /* APPLE LOCAL begin radar 4290840 */ - if (params == NULL_TREE) - { - cp_parser_error (parser, "objective-c++ method declaration is expected"); - return error_mark_node; - } - /* APPLE LOCAL end radar 4290840 */ - - return params; -} - -/* Parse the non-keyword Objective-C params. */ - -static tree -/* APPLE LOCAL radar 3803157 - objc attribute */ -cp_parser_objc_method_tail_params_opt (cp_parser* parser, bool *ellipsisp, tree* attributes) -{ - tree params = make_node (TREE_LIST); - cp_token *token = cp_lexer_peek_token (parser->lexer); - *ellipsisp = false; /* Initially, assume no ellipsis. */ - - while (token->type == CPP_COMMA) - { - cp_parameter_declarator *parmdecl; - tree parm; - - cp_lexer_consume_token (parser->lexer); /* Eat ','. */ - token = cp_lexer_peek_token (parser->lexer); - - if (token->type == CPP_ELLIPSIS) - { - cp_lexer_consume_token (parser->lexer); /* Eat '...'. */ - *ellipsisp = true; - /* APPLE LOCAL radar 3803157 - objc attribute */ - cp_parser_objc_maybe_attributes (parser, attributes); - break; - } - - parmdecl = cp_parser_parameter_declaration (parser, false, NULL); - parm = grokdeclarator (parmdecl->declarator, - &parmdecl->decl_specifiers, - PARM, /*initialized=*/0, - /*attrlist=*/NULL); - - chainon (params, build_tree_list (NULL_TREE, parm)); - token = cp_lexer_peek_token (parser->lexer); - } - - return params; -} - -/* Parse a linkage specification, a pragma, an extra semicolon or a block. */ - -static void -cp_parser_objc_interstitial_code (cp_parser* parser) -{ - cp_token *token = cp_lexer_peek_token (parser->lexer); - - /* If the next token is `extern' and the following token is a string - literal, then we have a linkage specification. */ - if (token->keyword == RID_EXTERN - && cp_parser_is_string_literal (cp_lexer_peek_nth_token (parser->lexer, 2))) - cp_parser_linkage_specification (parser); - /* Handle #pragma, if any. */ - else if (token->type == CPP_PRAGMA) - cp_parser_pragma (parser, pragma_external); - /* Allow stray semicolons. */ - else if (token->type == CPP_SEMICOLON) - cp_lexer_consume_token (parser->lexer); - /* APPLE LOCAL begin C* language */ - else if (token->keyword == RID_AT_OPTIONAL) - { - cp_lexer_consume_token (parser->lexer); - objc_set_method_opt (1); - } - else if (token->keyword == RID_AT_REQUIRED) - { - cp_lexer_consume_token (parser->lexer); - objc_set_method_opt (0); - } - /* APPLE LOCAL end C* language */ - /* APPLE LOCAL begin radar 4508851 */ - else if (token->keyword == RID_NAMESPACE) - cp_parser_namespace_definition (parser); - /* APPLE LOCAL end radar 4508851 */ - /* APPLE LOCAL begin 4093475 */ - /* Other stray characters must generate errors. */ - else if (token->type == CPP_OPEN_BRACE || token->type == CPP_CLOSE_BRACE) - { - cp_lexer_consume_token (parser->lexer); - error ("stray %<%s%> between Objective-C++ methods", - token->type == CPP_OPEN_BRACE ? "{" : "}"); - } - /* APPLE LOCAL end 4093475 */ - /* APPLE LOCAL begin radar 5976344 */ - else if (token->keyword == RID_TEMPLATE) - cp_parser_declaration (parser); - /* APPLE LOCAL end radar 5976344 */ - /* Finally, try to parse a block-declaration, or a function-definition. */ - else - cp_parser_block_declaration (parser, /*statement_p=*/false); -} - -/* Parse a method signature. */ - -static tree -/* APPLE LOCAL radar 3803157 - objc attribute */ -cp_parser_objc_method_signature (cp_parser* parser, tree* attributes) -{ - tree rettype, kwdparms, optparms; - bool ellipsis = false; - - cp_parser_objc_method_type (parser); - rettype = cp_parser_objc_typename (parser); - /* APPLE LOCAL begin radar 3803157 - objc attribute */ - *attributes = NULL_TREE; - kwdparms = cp_parser_objc_method_keyword_params (parser, attributes); - optparms = cp_parser_objc_method_tail_params_opt (parser, &ellipsis, attributes); - /* APPLE LOCAL end radar 3803157 - objc attribute */ - - return objc_build_method_signature (rettype, kwdparms, optparms, ellipsis); -} - -/* APPLE LOCAL Pars --> Parse */ -/* Parse an Objective-C method prototype list. */ - -static void -cp_parser_objc_method_prototype_list (cp_parser* parser) -{ - cp_token *token = cp_lexer_peek_token (parser->lexer); - - /* APPLE LOCAL 4093475 */ - while (token->keyword != RID_AT_END && token->type != CPP_EOF) - { - if (token->type == CPP_PLUS || token->type == CPP_MINUS) - { - /* APPLE LOCAL begin radar 3803157 - objc attribute */ - tree attributes, sig; - sig = cp_parser_objc_method_signature (parser, &attributes); - objc_add_method_declaration (sig, attributes); - /* APPLE LOCAL end radar 3803157 - objc attribute */ - cp_parser_consume_semicolon_at_end_of_statement (parser); - } - /* APPLE LOCAL begin C* interface */ - else if (token->keyword == RID_AT_PROPERTY) - objc_cp_parser_at_property (parser); - /* APPLE LOCAL end C* interface */ - else - /* Allow for interspersed non-ObjC++ code. */ - cp_parser_objc_interstitial_code (parser); - - token = cp_lexer_peek_token (parser->lexer); - } - - /* APPLE LOCAL 4093475 */ - cp_parser_require_keyword (parser, RID_AT_END, "`@end'"); - objc_finish_interface (); -} - -/* Parse an Objective-C method definition list. */ - -static void -cp_parser_objc_method_definition_list (cp_parser* parser) -{ - cp_token *token = cp_lexer_peek_token (parser->lexer); - - /* APPLE LOCAL 4093475 */ - while (token->keyword != RID_AT_END && token->type != CPP_EOF) - { - tree meth; - - if (token->type == CPP_PLUS || token->type == CPP_MINUS) - { - /* APPLE LOCAL radar 4290840 */ - cp_token *ptk; - /* APPLE LOCAL begin radar 3803157 - objc attribute */ - tree sig, attribute; - push_deferring_access_checks (dk_deferred); - sig = cp_parser_objc_method_signature (parser, &attribute); - objc_start_method_definition (sig, attribute); - /* APPLE LOCAL end radar 3803157 - objc attribute */ - - /* For historical reasons, we accept an optional semicolon. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) - cp_lexer_consume_token (parser->lexer); - - /* APPLE LOCAL begin radar 4290840 */ - /* Check for all possibilities of illegal lookahead tokens. */ - ptk = cp_lexer_peek_token (parser->lexer); - /* APPLE LOCAL radar 6271728 */ - if (ptk->type == CPP_OPEN_BRACE) - { - perform_deferred_access_checks (); - stop_deferring_access_checks (); - meth = cp_parser_function_definition_after_declarator (parser, - false); - pop_deferring_access_checks (); - objc_finish_method_definition (meth); - } - /* APPLE LOCAL begin radar 6271728 */ - else - cp_parser_require (parser, CPP_OPEN_BRACE, "`{'"); - /* APPLE LOCAL end radar 6271728 */ - /* APPLE LOCAL end radar 4290840 */ - } - /* APPLE LOCAL begin C* interface */ - else if (token->keyword == RID_AT_PROPERTY) - objc_cp_parser_at_property (parser); - /* APPLE LOCAL end C* interface */ - /* APPLE LOCAL begin objc new property */ - else if (token->keyword == RID_AT_SYNTHESIZE - || token->keyword == RID_AT_DYNAMIC) - objc_cp_parser_property_impl (parser, token->keyword); - /* APPLE LOCAL end objc new property */ - else - /* Allow for interspersed non-ObjC++ code. */ - cp_parser_objc_interstitial_code (parser); - - token = cp_lexer_peek_token (parser->lexer); - } - - /* APPLE LOCAL 4093475 */ - cp_parser_require_keyword (parser, RID_AT_END, "`@end'"); - objc_finish_implementation (); -} - -/* Parse Objective-C ivars. */ - -static void -cp_parser_objc_class_ivars (cp_parser* parser) -{ - cp_token *token = cp_lexer_peek_token (parser->lexer); - - if (token->type != CPP_OPEN_BRACE) - return; /* No ivars specified. */ - - cp_lexer_consume_token (parser->lexer); /* Eat '{'. */ - token = cp_lexer_peek_token (parser->lexer); - - /* APPLE LOCAL begin radar 4261146 */ - while (token->type != CPP_CLOSE_BRACE - && token->keyword != RID_AT_END - && token->type != CPP_EOF) - /* APPLE LOCAL end radar 4261146 */ - { - cp_decl_specifier_seq declspecs; - int decl_class_or_enum_p; - tree prefix_attributes; - - cp_parser_objc_visibility_spec (parser); - - if (cp_lexer_next_token_is (parser->lexer, CPP_CLOSE_BRACE)) - break; - - cp_parser_decl_specifier_seq (parser, - CP_PARSER_FLAGS_OPTIONAL, - &declspecs, - &decl_class_or_enum_p); - /* APPLE LOCAL begin radar 4360010 */ - if (declspecs.storage_class == sc_static) - { - error ("storage class specified for ivar"); - /* recover */ - declspecs.storage_class = sc_none; - } - /* APPLE LOCAL end radar 4360010 */ - /* APPLE LOCAL begin radar 4652027 */ - else if (declspecs.specs[(int) ds_typedef]) - { - error ("typedef declaration among ivars"); - cp_lexer_consume_token (parser->lexer); /* recover */ - } - /* APPLE LOCAL end radar 4652027 */ - prefix_attributes = declspecs.attributes; - declspecs.attributes = NULL_TREE; - - /* Keep going until we hit the `;' at the end of the - declaration. */ - while (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - { - tree width = NULL_TREE, attributes, first_attribute, decl; - cp_declarator *declarator = NULL; - int ctor_dtor_or_conv_p; - - /* Check for a (possibly unnamed) bitfield declaration. */ - token = cp_lexer_peek_token (parser->lexer); - if (token->type == CPP_COLON) - goto eat_colon; - - if (token->type == CPP_NAME - && (cp_lexer_peek_nth_token (parser->lexer, 2)->type - == CPP_COLON)) - { - /* Get the name of the bitfield. */ - declarator = make_id_declarator (NULL_TREE, - cp_parser_identifier (parser), - sfk_none); - - eat_colon: - cp_lexer_consume_token (parser->lexer); /* Eat ':'. */ - /* Get the width of the bitfield. */ - width - = cp_parser_constant_expression (parser, - /*allow_non_constant=*/false, - NULL); - } - else - { - /* Parse the declarator. */ - declarator - = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_NAMED, - &ctor_dtor_or_conv_p, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - } - - /* Look for attributes that apply to the ivar. */ - attributes = cp_parser_attributes_opt (parser); - /* Remember which attributes are prefix attributes and - which are not. */ - first_attribute = attributes; - /* Combine the attributes. */ - attributes = chainon (prefix_attributes, attributes); - - if (width) - { - /* Create the bitfield declaration. */ - decl = grokbitfield (declarator, &declspecs, width); - cplus_decl_attributes (&decl, attributes, /*flags=*/0); - } - else - decl = grokfield (declarator, &declspecs, - NULL_TREE, /*init_const_expr_p=*/false, - NULL_TREE, attributes); - - /* Add the instance variable. */ - objc_add_instance_variable (decl); - - /* Reset PREFIX_ATTRIBUTES. */ - while (attributes && TREE_CHAIN (attributes) != first_attribute) - attributes = TREE_CHAIN (attributes); - if (attributes) - TREE_CHAIN (attributes) = NULL_TREE; - - token = cp_lexer_peek_token (parser->lexer); - - if (token->type == CPP_COMMA) - { - cp_lexer_consume_token (parser->lexer); /* Eat ','. */ - continue; - } - break; - } - - cp_parser_consume_semicolon_at_end_of_statement (parser); - token = cp_lexer_peek_token (parser->lexer); - } - - cp_lexer_consume_token (parser->lexer); /* Eat '}'. */ - /* For historical reasons, we accept an optional semicolon. */ - if (cp_lexer_next_token_is (parser->lexer, CPP_SEMICOLON)) - cp_lexer_consume_token (parser->lexer); -} - -/* Parse an Objective-C protocol declaration. */ - -static void -/* APPLE LOCAL radar 4947311 */ -cp_parser_objc_protocol_declaration (cp_parser* parser, tree attributes) -{ - tree proto, protorefs; - cp_token *tok; - - cp_lexer_consume_token (parser->lexer); /* Eat '@protocol'. */ - if (cp_lexer_next_token_is_not (parser->lexer, CPP_NAME)) - { - error ("identifier expected after %<@protocol%>"); - goto finish; - } - - /* See if we have a forward declaration or a definition. */ - tok = cp_lexer_peek_nth_token (parser->lexer, 2); - - /* Try a forward declaration first. */ - if (tok->type == CPP_COMMA || tok->type == CPP_SEMICOLON) - { - /* APPLE LOCAL radar 4947311 */ - objc_declare_protocols (cp_parser_objc_identifier_list (parser), attributes); - finish: - cp_parser_consume_semicolon_at_end_of_statement (parser); - } - - /* Ok, we got a full-fledged definition (or at least should). */ - else - { - proto = cp_parser_identifier (parser); - protorefs = cp_parser_objc_protocol_refs_opt (parser); - /* APPLE LOCAL radar 4947311 */ - objc_start_protocol (proto, protorefs, attributes); - cp_parser_objc_method_prototype_list (parser); - } -} - -/* Parse an Objective-C superclass or category. */ - -/* APPLE LOCAL begin radar 4965989 */ -static void -cp_parser_objc_superclass_or_category (cp_parser *parser, tree *super, - tree *categ, bool *is_category) -{ - cp_token *next = cp_lexer_peek_token (parser->lexer); - - *super = *categ = NULL_TREE; - *is_category = false; - if (next->type == CPP_COLON) - { - cp_lexer_consume_token (parser->lexer); /* Eat ':'. */ - *super = cp_parser_identifier (parser); - } - else if (next->type == CPP_OPEN_PAREN) - { - cp_lexer_consume_token (parser->lexer); /* Eat '('. */ - /* APPLE LOCAL begin radar 4965989 */ - next = cp_lexer_peek_token (parser->lexer); - *categ = (next->type == CPP_CLOSE_PAREN) ? NULL_TREE : cp_parser_identifier (parser); - *is_category = true; - /* APPLE LOCAL end radar 4965989 */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - } -} -/* APPLE LOCAL end radar 4965989 */ - -/* Parse an Objective-C class interface. */ - -static void -/* APPLE LOCAL radar 4947311 */ -cp_parser_objc_class_interface (cp_parser* parser, tree attributes) -{ - tree name, super, categ, protos; - /* APPLE LOCAL radar 4965989 */ - bool is_categ; - /* APPLE LOCAL radar 4947311 */ - /* Code for radar 4548636 removed. */ - cp_lexer_consume_token (parser->lexer); /* Eat '@interface'. */ - name = cp_parser_identifier (parser); - /* APPLE LOCAL radar 4965989 */ - cp_parser_objc_superclass_or_category (parser, &super, &categ, &is_categ); - protos = cp_parser_objc_protocol_refs_opt (parser); - - /* We have either a class or a category on our hands. */ - /* APPLE LOCAL radar 4965989 */ - if (is_categ) - /* APPLE LOCAL begin radar 4548636 */ - { - if (attributes) - error ("attributes may not be specified on a category"); - objc_start_category_interface (name, categ, protos); - } - /* APPLE LOCAL end radar 4548636 */ - else - { - /* APPLE LOCAL radar 4548636 */ - objc_start_class_interface (name, super, protos, attributes); - /* Handle instance variable declarations, if any. */ - cp_parser_objc_class_ivars (parser); - objc_continue_interface (); - } - - cp_parser_objc_method_prototype_list (parser); -} - -/* Parse an Objective-C class implementation. */ - -static void -cp_parser_objc_class_implementation (cp_parser* parser) -{ - tree name, super, categ; - /* APPLE LOCAL radar 4965989 */ - bool is_categ; - cp_lexer_consume_token (parser->lexer); /* Eat '@implementation'. */ - name = cp_parser_identifier (parser); - /* APPLE LOCAL radar 4965989 */ - cp_parser_objc_superclass_or_category (parser, &super, &categ, &is_categ); - - /* We have either a class or a category on our hands. */ - /* APPLE LOCAL begin radar 4965989 */ - if (is_categ) - { - if (categ == NULL_TREE) - { - error ("cannot implement anonymous category"); - return; - } - objc_start_category_implementation (name, categ); - } - /* APPLE LOCAL end radar 4965989 */ - else - { - objc_start_class_implementation (name, super); - /* Handle instance variable declarations, if any. */ - cp_parser_objc_class_ivars (parser); - objc_continue_implementation (); - } - - cp_parser_objc_method_definition_list (parser); -} - -/* Consume the @end token and finish off the implementation. */ - -static void -cp_parser_objc_end_implementation (cp_parser* parser) -{ - cp_lexer_consume_token (parser->lexer); /* Eat '@end'. */ - objc_finish_implementation (); -} - -/* Parse an Objective-C declaration. */ - -static void -cp_parser_objc_declaration (cp_parser* parser) -{ - /* Try to figure out what kind of declaration is present. */ - cp_token *kwd = cp_lexer_peek_token (parser->lexer); - - switch (kwd->keyword) - { - case RID_AT_ALIAS: - cp_parser_objc_alias_declaration (parser); - break; - case RID_AT_CLASS: - cp_parser_objc_class_declaration (parser); - break; - case RID_AT_PROTOCOL: - /* APPLE LOCAL radar 4947311 */ - cp_parser_objc_protocol_declaration (parser, NULL_TREE); - break; - /* APPLE LOCAL begin radar 4548636 - radar 4947311 */ - case RID_ATTRIBUTE: - { - tree attributes = NULL_TREE; - cp_parser_objc_maybe_attributes (parser, &attributes); - if (cp_lexer_peek_token (parser->lexer)->keyword == RID_AT_INTERFACE) - cp_parser_objc_class_interface (parser, attributes); - else if (cp_lexer_peek_token (parser->lexer)->keyword == RID_AT_PROTOCOL) - cp_parser_objc_protocol_declaration (parser, attributes); - break; - } - /* APPLE LOCAL end radar 4548636 - radar 4947311 */ - case RID_AT_INTERFACE: - /* APPLE LOCAL radar 4947311 */ - cp_parser_objc_class_interface (parser, NULL_TREE); - break; - case RID_AT_IMPLEMENTATION: - cp_parser_objc_class_implementation (parser); - break; - case RID_AT_END: - cp_parser_objc_end_implementation (parser); - break; - default: - error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value); - cp_parser_skip_to_end_of_block_or_statement (parser); - } -} - -/* Parse an Objective-C try-catch-finally statement. - - objc-try-catch-finally-stmt: - @try compound-statement objc-catch-clause-seq [opt] - objc-finally-clause [opt] - - objc-catch-clause-seq: - objc-catch-clause objc-catch-clause-seq [opt] - - objc-catch-clause: - @catch ( exception-declaration ) compound-statement - - objc-finally-clause - @finally compound-statement - - Returns NULL_TREE. */ - -static tree -cp_parser_objc_try_catch_finally_statement (cp_parser *parser) { - location_t location; - tree stmt; - - cp_parser_require_keyword (parser, RID_AT_TRY, "`@try'"); - location = cp_lexer_peek_token (parser->lexer)->location; - /* NB: The @try block needs to be wrapped in its own STATEMENT_LIST - node, lest it get absorbed into the surrounding block. */ - stmt = push_stmt_list (); - /* APPLE LOCAL radar 5982990 */ - cp_parser_compound_statement (parser, NULL, false, false); - objc_begin_try_stmt (location, pop_stmt_list (stmt)); - - while (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_CATCH)) - { - cp_parameter_declarator *parmdecl; - tree parm; - /* APPLE LOCAL radar 2848255 */ - bool ellipsis_seen = false; - - cp_lexer_consume_token (parser->lexer); - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - /* APPLE LOCAL begin radar 2848255 */ - /* APPLE LOCAL begin radar 4995967 */ - { - cp_token *token = cp_lexer_peek_token (parser->lexer); - if (token->type == CPP_ELLIPSIS) - { - /* @catch (...) */ - parm = NULL_TREE; - cp_lexer_consume_token (parser->lexer); - ellipsis_seen = true; - } - } - /* APPLE LOCAL end radar 4995967 */ - if (!ellipsis_seen) - { - parmdecl = cp_parser_parameter_declaration (parser, false, NULL); - parm = grokdeclarator (parmdecl->declarator, - &parmdecl->decl_specifiers, - PARM, /*initialized=*/0, - /*attrlist=*/NULL); - } - /* APPLE LOCAL end radar 2848255 */ - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - objc_begin_catch_clause (parm); - /* APPLE LOCAL radar 5982990 */ - cp_parser_compound_statement (parser, NULL, false, false); - objc_finish_catch_clause (); - } - - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_AT_FINALLY)) - { - cp_lexer_consume_token (parser->lexer); - location = cp_lexer_peek_token (parser->lexer)->location; - /* NB: The @finally block needs to be wrapped in its own STATEMENT_LIST - node, lest it get absorbed into the surrounding block. */ - stmt = push_stmt_list (); - /* APPLE LOCAL radar 5982990 */ - cp_parser_compound_statement (parser, NULL, false, false); - objc_build_finally_clause (location, pop_stmt_list (stmt)); - } - - return objc_finish_try_stmt (); -} - -/* Parse an Objective-C synchronized statement. - - objc-synchronized-stmt: - @synchronized ( expression ) compound-statement - - Returns NULL_TREE. */ - -static tree -cp_parser_objc_synchronized_statement (cp_parser *parser) { - location_t location; - tree lock, stmt; - - cp_parser_require_keyword (parser, RID_AT_SYNCHRONIZED, "`@synchronized'"); - - location = cp_lexer_peek_token (parser->lexer)->location; - cp_parser_require (parser, CPP_OPEN_PAREN, "`('"); - lock = cp_parser_expression (parser, false); - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - /* NB: The @synchronized block needs to be wrapped in its own STATEMENT_LIST - node, lest it get absorbed into the surrounding block. */ - stmt = push_stmt_list (); - /* APPLE LOCAL radar 5982990 */ - cp_parser_compound_statement (parser, NULL, false, flag_objc_sjlj_exceptions); - - return objc_build_synchronized (location, lock, pop_stmt_list (stmt)); -} - -/* Parse an Objective-C throw statement. - - objc-throw-stmt: - @throw assignment-expression [opt] ; - - Returns a constructed '@throw' statement. */ - -static tree -cp_parser_objc_throw_statement (cp_parser *parser) { - tree expr = NULL_TREE; - - cp_parser_require_keyword (parser, RID_AT_THROW, "`@throw'"); - - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - expr = cp_parser_assignment_expression (parser, false); - - cp_parser_consume_semicolon_at_end_of_statement (parser); - - return objc_build_throw_stmt (expr); -} - -/* Parse an Objective-C statement. */ - -static tree -cp_parser_objc_statement (cp_parser * parser) { - /* Try to figure out what kind of declaration is present. */ - cp_token *kwd = cp_lexer_peek_token (parser->lexer); - - switch (kwd->keyword) - { - case RID_AT_TRY: - return cp_parser_objc_try_catch_finally_statement (parser); - case RID_AT_SYNCHRONIZED: - return cp_parser_objc_synchronized_statement (parser); - case RID_AT_THROW: - return cp_parser_objc_throw_statement (parser); - default: - error ("misplaced %<@%D%> Objective-C++ construct", kwd->u.value); - cp_parser_skip_to_end_of_block_or_statement (parser); - } - - return error_mark_node; -} - -/* APPLE LOCAL begin C* language */ -/* Routine closes up the C*'s foreach statement. -*/ - -static void -objc_finish_foreach_stmt (tree for_stmt) -{ - if (flag_new_for_scope > 0) - { - tree scope = TREE_CHAIN (for_stmt); - TREE_CHAIN (for_stmt) = NULL; - add_stmt (do_poplevel (scope)); - } - - finish_stmt (); -} - -/* - Synthesizer routine for C*'s feareach statement. - - It synthesizes: - for ( type elem in collection) { stmts; } - - Into: - { - type elem; - __objcFastEnumerationState enumState = { 0 }; - id items[16]; - - unsigned long limit = [collection countByEnumeratingWithState:&enumState objects:items count:16]; - if (limit) { - unsigned long startMutations = *enumState.mutationsPtr; - do { - unsigned long counter = 0; - do { - if (startMutations != *enumState.mutationsPtr) objc_enumerationMutation(collection); - elem = enumState.itemsPtr[counter++]; - stmts; - } while (counter < limit); - } while (limit = [collection countByEnumeratingWithState:&enumState objects:items count:16]); - } - else - elem = nil; radar 4854605, 5128402 - -*/ - -static void -objc_foreach_stmt (cp_parser* parser, tree statement) -{ - unsigned char in_statement; - tree enumerationMutation_call_exp; - tree countByEnumeratingWithState; - tree receiver; - tree exp, bind; - tree enumState_decl, items_decl; - tree limit_decl, limit_decl_assign_expr; - tree outer_if_stmt, inner_if_stmt, if_condition, startMutations_decl; - tree outer_do_stmt, inner_do_stmt, do_condition; - tree counter_decl; - tree_stmt_iterator i = tsi_start (TREE_CHAIN (statement)); - tree t = tsi_stmt (i); - /* APPLE LOCAL radar 5130983 */ - tree elem_decl = TREE_CODE (t) == DECL_EXPR ? DECL_EXPR_DECL (t) : t; - - receiver = cp_parser_condition (parser); - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - - /* APPLE LOCAL begin radar 5130983 */ - if (elem_decl == error_mark_node) - return; - if (!lvalue_or_else (&elem_decl, lv_foreach)) - return; - /* APPLE LOCAL end radar 5130983 */ - - /* APPLE LOCAL begin radar 4507230 */ - if (!objc_type_valid_for_messaging (TREE_TYPE (elem_decl))) - { - error ("selector element does not have a valid object type"); - return; - } - - if (!objc_type_valid_for_messaging (TREE_TYPE (receiver))) - { - error ("expression does not have a valid object type"); - return; - } - /* APPLE LOCAL end radar 4507230 */ - - enumerationMutation_call_exp = objc_build_foreach_components (receiver, &enumState_decl, - &items_decl, &limit_decl, - &startMutations_decl, &counter_decl, - &countByEnumeratingWithState); - - /* __objcFastEnumerationState enumState = { 0 }; */ - exp = build_stmt (DECL_EXPR, enumState_decl); - bind = build3 (BIND_EXPR, void_type_node, enumState_decl, exp, NULL); - TREE_SIDE_EFFECTS (bind) = 1; - add_stmt (bind); - - /* id items[16]; */ - bind = build3 (BIND_EXPR, void_type_node, items_decl, NULL, NULL); - TREE_SIDE_EFFECTS (bind) = 1; - add_stmt (bind); - - /* Generate this statement and add it to the list. */ - /* limit = [collection countByEnumeratingWithState:&enumState objects:items count:16] */ - limit_decl_assign_expr = build2 (MODIFY_EXPR, TREE_TYPE (limit_decl), limit_decl, - countByEnumeratingWithState); - bind = build3 (BIND_EXPR, void_type_node, limit_decl, NULL, NULL); - TREE_SIDE_EFFECTS (bind) = 1; - add_stmt (bind); - - /* if (limit) { */ - outer_if_stmt = begin_if_stmt (); - /* APPLE LOCAL radar 4547045 */ - if_condition = build_binary_op (NE_EXPR, limit_decl_assign_expr, - fold_convert (TREE_TYPE (limit_decl), integer_zero_node), - 1); - - finish_if_stmt_cond (if_condition, outer_if_stmt); - - /* unsigned long startMutations = *enumState.mutationsPtr; */ - exp = objc_build_component_ref (enumState_decl, get_identifier("mutationsPtr")); - exp = build_indirect_ref (exp, "unary *"); - exp = build2 (MODIFY_EXPR, void_type_node, startMutations_decl, exp); - bind = build3 (BIND_EXPR, void_type_node, startMutations_decl, exp, NULL); - TREE_SIDE_EFFECTS (bind) = 1; - add_stmt (bind); - - /* do { */ -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - outer_do_stmt = begin_do_stmt (NULL_TREE); - -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - /* Body of the outer do-while loop */ - /* unsigned int counter = 0; */ - exp = build2 (MODIFY_EXPR, void_type_node, counter_decl, - fold_convert (TREE_TYPE (counter_decl), integer_zero_node)); - bind = build3 (BIND_EXPR, void_type_node, counter_decl, exp, NULL); - TREE_SIDE_EFFECTS (bind) = 1; - add_stmt (bind); - - /* do { */ -/* APPLE LOCAL begin for-fsf-4_4 3274130 5295549 */ \ - inner_do_stmt = begin_do_stmt (NULL_TREE); - -/* APPLE LOCAL end for-fsf-4_4 3274130 5295549 */ \ - /* Body of the inner do-while loop */ - - /* if (startMutations != *enumState.mutationsPtr) objc_enumerationMutation (collection); */ - inner_if_stmt = begin_if_stmt (); - exp = objc_build_component_ref (enumState_decl, get_identifier("mutationsPtr")); - exp = build_indirect_ref (exp, "unary *"); - if_condition = build_binary_op (NE_EXPR, startMutations_decl, exp, 1); - finish_if_stmt_cond (if_condition, inner_if_stmt); - - add_stmt (enumerationMutation_call_exp); - finish_then_clause (inner_if_stmt); - finish_if_stmt (inner_if_stmt); - - /* elem = enumState.itemsPtr [counter]; */ - exp = objc_build_component_ref (enumState_decl, get_identifier("itemsPtr")); - exp = build_array_ref (exp, counter_decl); - add_stmt (build2 (MODIFY_EXPR, void_type_node, elem_decl, exp)); - /* APPLE LOCAL radar 4538105 */ - TREE_USED (elem_decl) = 1; - - /* counter++; */ - exp = build2 (PLUS_EXPR, TREE_TYPE (counter_decl), counter_decl, - build_int_cst (NULL_TREE, 1)); - add_stmt (build2 (MODIFY_EXPR, void_type_node, counter_decl, exp)); - - /* ADD << stmts >> from the foreach loop. */ - /* Parse the body of the for-statement. */ - in_statement = parser->in_statement; - parser->in_statement = IN_ITERATION_STMT; - cp_parser_already_scoped_statement (parser); - parser->in_statement = in_statement; - - finish_do_body (inner_do_stmt); - - /* } while (counter < limit ); */ - do_condition = build_binary_op (LT_EXPR, counter_decl, limit_decl, 1); - finish_do_stmt (do_condition, inner_do_stmt); - DO_FOREACH (inner_do_stmt) = integer_zero_node; - /* APPLE LOCAL radar 4667060 */ - DO_FOREACH (outer_do_stmt) = elem_decl; - - finish_do_body (outer_do_stmt); - - /* } while (limit = [collection countByEnumeratingWithState:&enumState objects:items count:16]); */ - - exp = unshare_expr (limit_decl_assign_expr); - do_condition = build_binary_op (NE_EXPR, exp, - fold_convert (TREE_TYPE (limit_decl), integer_zero_node), - 1); - finish_do_stmt (do_condition, outer_do_stmt); - - - finish_then_clause (outer_if_stmt); - - /* } */ - /* APPLE LOCAL begin radar 4854605 - radar 5128402 */ - begin_else_clause (outer_if_stmt); - add_stmt (build2 (MODIFY_EXPR, void_type_node, elem_decl, - fold_convert (TREE_TYPE (elem_decl), integer_zero_node))); - finish_else_clause (outer_if_stmt); - /* APPLE LOCAL end radar 4854605 - radar 5128402 */ - - finish_if_stmt (outer_if_stmt); - - objc_finish_foreach_stmt (statement); -} -/* APPLE LOCAL end C* language */ -/* APPLE LOCAL begin blocks 6040305 (ce) */ -#define I_SYMBOL_BINDING(t) IDENTIFIER_BINDING(t) - -tree build_component_ref (tree e, tree member); -tree -build_component_ref (tree e, tree member) -{ - if (!DECL_P (member)) - member = lookup_member (TREE_TYPE (e), member, 0, 0); - if (processing_template_decl) - return build3 (COMPONENT_REF, TREE_TYPE (member), e, DECL_NAME (member), NULL_TREE); - return build_class_member_access_expr (e, member, - NULL_TREE, false); -} - -/* APPLE LOCAL begin radar 6214617 */ -static bool -cp_block_requires_copying (tree exp) -{ - return (block_requires_copying (exp) - || TYPE_HAS_CONSTRUCTOR (TREE_TYPE (exp)) - || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (exp))); -} -/* APPLE LOCAL end radar 6214617 */ - -/* APPLE LOCAL begin radar 5847213 - radar 6329245 */ -/** build_descriptor_block_decl - - This routine builds a static block_descriptior variable of type: - struct __block_descriptor; and initializes it to: - {0, sizeof(struct literal_block_n), - copy_helper_block_1, // only if block BLOCK_HAS_COPY_DISPOSE - destroy_helper_block_1, // only if block BLOCK_HAS_COPY_DISPOSE - } -*/ -static tree -build_descriptor_block_decl (tree block_struct_type, struct block_sema_info *block_impl) -{ - extern tree create_tmp_var_raw (tree, const char *); - static int desc_unique_count; - int size; - tree helper_addr; - tree decl, constructor; - char name [32]; - VEC(constructor_elt,gc) *impl_v = NULL; - tree descriptor_type = - TREE_TYPE (build_block_descriptor_type (block_impl->BlockHasCopyDispose)); - - sprintf (name, "__block_descriptor_tmp_%d", ++desc_unique_count); - decl = create_tmp_var_raw (descriptor_type, name); - DECL_CONTEXT (decl) = NULL_TREE; - - /* Initialize "reserved" field to 0 for now. */ - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, build_int_cst (long_unsigned_type_node, 0)); - - /* Initialize "Size" field. */ - size = TREE_INT_CST_LOW (TYPE_SIZE_UNIT (block_struct_type)); - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, build_int_cst (long_unsigned_type_node, size)); - - if (block_impl->BlockHasCopyDispose) - { - /* Initialize "CopyFuncPtr" and "DestroyFuncPtr" fields. */ - /* Helpers were previously generated completeley as a nested - function (and context was required for code gen.) But they are not, - so context must be set to NULL so initialization logic does not complain. */ - DECL_CONTEXT (block_impl->copy_helper_func_decl) = NULL_TREE; - helper_addr = build_fold_addr_expr (block_impl->copy_helper_func_decl); - helper_addr = convert (ptr_type_node, helper_addr); - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, helper_addr); - - DECL_CONTEXT (block_impl->destroy_helper_func_decl) = NULL_TREE; - helper_addr = build_fold_addr_expr (block_impl->destroy_helper_func_decl); - helper_addr = convert (ptr_type_node, helper_addr); - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, helper_addr); - } - /* Create a CONSTRUCTOR to represent the braced-initializer. */ - constructor = make_node (CONSTRUCTOR); - CONSTRUCTOR_ELTS (constructor) = impl_v; - TREE_PUBLIC (decl) = 0; - TREE_STATIC (decl) = 1; - cp_finish_decl (decl, constructor, 0, 0, LOOKUP_ONLYCONVERTING); - return decl; -} - -/* APPLE LOCAL begin radar 6300081 */ -/* This function builds a "generic" block struct type, to be passed - into the debug information for blocks pointers, to allow gdb to - find the actual function pointer for the block. Any time the Blocks - structure layout changes, this may also need to change. - - Currently a block pointer is a pointer to a __block_literal_n struct, - the third field of which is a pointer to a __block_descriptor struct, - whose third field is the function pointer. There are other fields as - well, but these are the ones gdb needs to know about to find the - function pointer. Therefore a generic block struct currently looks - like this: - - struct __block_literal_generic - { - void * __isa; - int __flags; - int __reserved; - void *__FuncPtr; - struct __block_descriptor - { - unsigned long int reserved; - unsigned long int Size; - } *__descriptor; - }; - - IF AT ANY TIME THE STRUCTURE OF A __BLOCK_LITERAL_N CHANGES, THIS - MUST BE CHANGED ALSO!! - -*/ - -tree -/* APPLE LOCAL radar 6353006 */ -c_build_generic_block_struct_type (void) -{ - tree fields = NULL_TREE; - tree field; - tree block_struct_type; - - push_to_top_level (); - block_struct_type = xref_tag (record_type, - get_identifier ("__block_literal_generic"), - ts_current, false); - xref_basetypes (block_struct_type, NULL_TREE); - CLASSTYPE_DECLARED_CLASS (block_struct_type) = 0; - pushclass (block_struct_type); - - field = build_decl (FIELD_DECL, get_identifier ("__isa"), ptr_type_node); - TREE_CHAIN (field) = fields; - fields = field; - - field = build_decl (FIELD_DECL, get_identifier ("__flags"), - integer_type_node); - TREE_CHAIN (field) = fields; - fields = field; - - field = build_decl (FIELD_DECL, get_identifier ("__reserved"), - integer_type_node); - TREE_CHAIN (field) = fields; - fields = field; - - field = build_decl (FIELD_DECL, get_identifier ("__FuncPtr"), - ptr_type_node); - TREE_CHAIN (field) = fields; - fields = field; - - field = build_decl (FIELD_DECL, get_identifier ("__descriptor"), - build_block_descriptor_type (false)); - TREE_CHAIN (field) = fields; - fields = field; - - TYPE_FIELDS (block_struct_type) = fields; - TYPE_NAME (block_struct_type) = build_decl (TYPE_DECL, - get_identifier ("__block_literal_generic"), - block_struct_type); - TYPE_STUB_DECL (block_struct_type) = TYPE_NAME (block_struct_type); - TYPE_BLOCK_IMPL_STRUCT (block_struct_type) = 1; - finish_struct (block_struct_type, NULL_TREE); - pop_from_top_level (); - - return block_struct_type; -} -/* APPLE LOCAL end radar 6300081 */ - -/** build_block_struct_type - - struct __block_literal_n { - void *__isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock - int __flags; - int __reserved; - void *__FuncPtr; - - struct __block_descriptor { - unsigned long int reserved; // NULL - unsigned long int Size; // sizeof(struct __block_literal_n) - - // optional helper functions - void *CopyFuncPtr; // When BLOCK_HAS_COPY_DISPOSE - void *DestroyFuncPtr; // When BLOCK_HAS_COPY_DISPOSE - } *__descriptor; - - // imported variables - int x; // ref variable list ... - int *y; // byref variable list - }; -*/ -static tree -build_block_struct_type (struct block_sema_info * block_impl) -{ - tree fields = NULL_TREE, field, chain; - char buffer[32]; - static int unique_count; - tree block_struct_type; - - /* Check and see if this block is required to have a Copy/Dispose - helper function. If yes, set BlockHasCopyDispose to TRUE. */ - for (chain = block_impl->block_ref_decl_list; chain; - chain = TREE_CHAIN (chain)) - /* APPLE LOCAL begin radar 6214617 */ - if (cp_block_requires_copying (TREE_VALUE (chain))) - { - tree type = TREE_TYPE (TREE_VALUE (chain)); - block_impl->BlockHasCopyDispose = TRUE; - if (TYPE_HAS_CONSTRUCTOR (type) || TYPE_NEEDS_CONSTRUCTING (type)) - { - block_impl->BlockImportsCxxObjects = TRUE; - break; - } - /* APPLE LOCAL end radar 6214617 */ - } - - /* Further check to see that we have __block variables which require - Copy/Dispose helpers. */ - for (chain = block_impl->block_byref_decl_list; chain; - chain = TREE_CHAIN (chain)) - if (COPYABLE_BYREF_LOCAL_VAR (TREE_VALUE (chain))) - { - block_impl->BlockHasCopyDispose = TRUE; - break; - } - - sprintf(buffer, "__block_literal_%d", ++unique_count); - push_to_top_level (); - /* APPLE LOCAL begin radar 6243400 */ - block_struct_type = xref_tag (record_type, get_identifier (buffer), ts_current, false); - xref_basetypes (block_struct_type, NULL_TREE); - CLASSTYPE_DECLARED_CLASS (block_struct_type) = 0; - pushclass (block_struct_type); - /* APPLE LOCAL end radar 6243400 */ - /* void * __isa; */ - field = build_decl (FIELD_DECL, get_identifier ("__isa"), ptr_type_node); - TREE_CHAIN (field) = fields; - fields = field; - - /* int __flags. */ - field = build_decl (FIELD_DECL, get_identifier ("__flags"), integer_type_node); - TREE_CHAIN (field) = fields; - fields = field; - - /* int __reserved. */ - field = build_decl (FIELD_DECL, get_identifier ("__reserved"), integer_type_node); - TREE_CHAIN (field) = fields; - fields = field; - - /* void *__FuncPtr. */ - field = build_decl (FIELD_DECL, get_identifier ("__FuncPtr"), - ptr_type_node); - TREE_CHAIN (field) = fields; - fields = field; - - /* struct __block_descriptor *__descriptor */ - field = build_decl (FIELD_DECL, get_identifier ("__descriptor"), - build_block_descriptor_type (block_impl->BlockHasCopyDispose)); - TREE_CHAIN (field) = fields; - fields = field; - - if (block_impl->BlockHasCopyDispose) - { - /* If inner block of a nested block has BlockHasCopyDispose, so - does its outer block. */ - if (block_impl->prev_block_info) - block_impl->prev_block_info->BlockHasCopyDispose = TRUE; - } - - /* int x; // ref variable list ... */ - for (chain = block_impl->block_ref_decl_list; chain; chain = TREE_CHAIN (chain)) - { - tree p = TREE_VALUE (chain); - /* Note! const-ness of copied in variable must not be carried over to the - type of the synthesized struct field. It prevents to assign to this - field when copy constructor is synthesized. */ - field = build_decl (FIELD_DECL, DECL_NAME (p), - c_build_qualified_type (TREE_TYPE (p), - TYPE_UNQUALIFIED)); - TREE_CHAIN (field) = fields; - fields = field; - } - - /* int *y; // byref variable list */ - for (chain = block_impl->block_byref_decl_list; chain; chain = TREE_CHAIN (chain)) - { - tree p = TREE_VALUE (chain); - field = build_decl (FIELD_DECL, DECL_NAME (p), - TREE_TYPE (p)); - TREE_CHAIN (field) = fields; - fields = field; - } - - /* APPLE LOCAL begin radar 6243400 */ - TYPE_FIELDS (block_struct_type) = fields; - TYPE_NAME (block_struct_type) = - build_decl (TYPE_DECL, get_identifier (buffer), block_struct_type); - TYPE_STUB_DECL (block_struct_type) = TYPE_NAME (block_struct_type); - finish_struct (block_struct_type, NULL_TREE); - pop_from_top_level (); - /* APPLE LOCAL end radar 6243400 */ - return block_struct_type; -} - -/** - build_block_struct_initlist - builds the initializer list: - { &_NSConcreteStackBlock or &_NSConcreteGlobalBlock // __isa, - BLOCK_USE_STRET | BLOCK_HAS_COPY_DISPOSE | BLOCK_IS_GLOBAL // __flags, - 0, // __reserved, - &helper_1, // __FuncPtr, - &static_descriptor_variable // __descriptor, - x, // user variables. - &y - ... - } -*/ -/* APPLE LOCAL begin radar 6169527 */ -/* This routine is entirely rewritten as we now have to deal with full-blown - c++ classes with fields which may require construction. */ -static VEC(constructor_elt,gc) * -build_block_struct_initlist (tree block_struct_type, - struct block_sema_info *block_impl) -{ - tree expr, chain, helper_addr; - /* APPLE LOCAL radar 7735196 */ - unsigned flags = 0; - static tree NSConcreteStackBlock_decl = NULL_TREE; - static tree NSConcreteGlobalBlock_decl = NULL_TREE; - VEC(constructor_elt,gc) *impl_v = NULL; - tree descriptor_block_decl = build_descriptor_block_decl (block_struct_type, block_impl); - - if (block_impl->BlockHasCopyDispose) - /* Note! setting of this flag merely indicates to the runtime that - we have destroy_helper_block/copy_helper_block helper - routines. */ - flags |= BLOCK_HAS_COPY_DISPOSE; - /* APPLE LOCAL begin radar 6214617 */ - /* Set BLOCK_HAS_CXX_OBJ if block is importing a cxx object. */ - if (block_impl->BlockImportsCxxObjects) - flags |= BLOCK_HAS_CXX_OBJ; - /* APPLE LOCAL end radar 6214617 */ -/* APPLE LOCAL begin radar 7735196 */ - if (block_impl->return_type && aggregate_value_p(block_impl->return_type, 0)) - flags |= BLOCK_USE_STRET; - /* APPLE LOCAL end 7735196 */ - /* APPLE LOCAL begin radar 6230297 */ - if (!current_function_decl || - (block_impl->block_ref_decl_list == NULL_TREE && - block_impl->block_byref_decl_list == NULL_TREE)) - /* APPLE LOCAL end radar 6230297 */ - { - /* This is a global block. */ - /* Find an existing declaration for _NSConcreteGlobalBlock or declare - extern void *_NSConcreteGlobalBlock; */ - if (NSConcreteGlobalBlock_decl == NULL_TREE) - { - tree name_id = get_identifier("_NSConcreteGlobalBlock"); - NSConcreteGlobalBlock_decl = lookup_name (name_id); - if (!NSConcreteGlobalBlock_decl) - { - NSConcreteGlobalBlock_decl = build_decl (VAR_DECL, name_id, ptr_type_node); - DECL_EXTERNAL (NSConcreteGlobalBlock_decl) = 1; - TREE_PUBLIC (NSConcreteGlobalBlock_decl) = 1; - pushdecl_top_level (NSConcreteGlobalBlock_decl); - rest_of_decl_compilation (NSConcreteGlobalBlock_decl, 0, 0); - } - } - /* APPLE LOCAL begin radar 6457359 */ - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, - convert (ptr_type_node, - build_fold_addr_expr (NSConcreteGlobalBlock_decl))); - /* APPLE LOCAL end radar 6457359 */ - flags |= BLOCK_IS_GLOBAL; - } - else - { - /* Find an existing declaration for _NSConcreteStackBlock or declare - extern void *_NSConcreteStackBlock; */ - if (NSConcreteStackBlock_decl == NULL_TREE) - { - tree name_id = get_identifier("_NSConcreteStackBlock"); - NSConcreteStackBlock_decl = lookup_name (name_id); - if (!NSConcreteStackBlock_decl) - { - NSConcreteStackBlock_decl = build_decl (VAR_DECL, name_id, ptr_type_node); - DECL_EXTERNAL (NSConcreteStackBlock_decl) = 1; - TREE_PUBLIC (NSConcreteStackBlock_decl) = 1; - pushdecl_top_level (NSConcreteStackBlock_decl); - rest_of_decl_compilation (NSConcreteStackBlock_decl, 0, 0); - } - } - /* APPLE LOCAL begin radar 6457359 */ - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, - convert (ptr_type_node, - build_fold_addr_expr (NSConcreteStackBlock_decl))); - /* APPLE LOCAL end radar 6457359 */ - } - - /* __flags */ - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, build_int_cst (integer_type_node, flags)); - /* __reserved */ - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, build_int_cst (integer_type_node, 0)); - /* __FuncPtr */ - helper_addr = build_fold_addr_expr (block_impl->helper_func_decl); - helper_addr = convert (ptr_type_node, helper_addr); - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, helper_addr); - - /* &static_descriptor_variable initializer */ - expr = build_fold_addr_expr (descriptor_block_decl); - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, expr); - - for (chain = block_impl->block_original_ref_decl_list; chain; - chain = TREE_CHAIN (chain)) - { - tree y = TREE_VALUE (chain); - TREE_USED (y) = 1; - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, y); - } - for (chain = block_impl->block_byref_decl_list; chain; - chain = TREE_CHAIN (chain)) - { - tree y = lookup_name (DECL_NAME (TREE_VALUE (chain))); - tree forwarding_expr; - gcc_assert (y); - TREE_USED (y) = 1; - if (COPYABLE_BYREF_LOCAL_VAR (y)) - { - /* For variables declared __block, either the original one - at the point of declaration or the imported version (which is - initialized in the helper function's prologue) is used to - initilize the byref variable field in the temporary. */ - if (TREE_CODE (TREE_TYPE (y)) != RECORD_TYPE) - y = build_indirect_ref (y, "unary *"); - /* We will be using the __block_struct_variable.__forwarding as the - initializer. */ - forwarding_expr = build_component_ref (y, get_identifier ("__forwarding")); - } - else - /* Global variable is always assumed passed by its address. */ - forwarding_expr = build_fold_addr_expr (y); - - CONSTRUCTOR_APPEND_ELT(impl_v, NULL_TREE, forwarding_expr); - } - return impl_v; -} -/* APPLE LOCAL end radar 6169527 */ -/* APPLE LOCAL end radar 5847213 - radar 6329245 */ - -/** - build_block_literal_tmp - This routine: - - 1) builds block type: - struct __block_literal_n { - void *__isa; // initialized to &_NSConcreteStackBlock or &_NSConcreteGlobalBlock - int __flags; - int __reserved; - void *__FuncPtr; - - struct __block_descriptor { - unsigned long int reserved; // NULL - unsigned long int Size; // sizeof(struct Block_literal_1) - - // optional helper functions - void *CopyFuncPtr; // When BLOCK_HAS_COPY_DISPOSE - void *DestroyFuncPtr; // When BLOCK_HAS_COPY_DISPOSE - } *__descriptor; - - // imported variables - int x; // ref variable list ... - int *y; // byref variable list - }; - - 2) build function prototype: - double helper_1(struct block_1 *ii, int z); - - 3) build the temporary initialization: - struct block_1 I = { - { &_NSConcreteStackBlock or &_NSConcreteGlobalBlock // isa, - BLOCK_HAS_CXX_OBJ | BLOCK_HAS_COPY_DISPOSE | BLOCK_IS_GLOBAL // flags, - 0, // reserved, - &helper_1, - &{ - NULL, - sizeof(struct block_1), - copy_helper_block_1, // only if block BLOCK_HAS_COPY_DISPOSE - destroy_helper_block_1, // only if block BLOCK_HAS_COPY_DISPOSE - }, - x, - &y -}; - -It return the temporary. -*/ -/* APPLE LOCAL begin radar 6169527 */ -static tree -build_block_literal_tmp (const char *name, - struct block_sema_info * block_impl) -{ - extern tree create_tmp_var_raw (tree, const char *); - tree block_holder_tmp_decl; - tree constructor; - tree block_struct_type = TREE_TYPE (block_impl->block_arg_ptr_type); - /* APPLE LOCAL begin radar 6230297 */ - bool staticBlockTmp = (block_impl->block_ref_decl_list == NULL_TREE && - block_impl->block_byref_decl_list == NULL_TREE); - - block_holder_tmp_decl = create_tmp_var_raw (block_struct_type, name); - /* Context will not be known until when the literal is synthesized. - This is more so in the case of nested block literal blocks. */ - maybe_push_decl (block_holder_tmp_decl); - DECL_CONTEXT (block_holder_tmp_decl) = staticBlockTmp ? NULL_TREE - : current_function_decl; - if (staticBlockTmp) - DECL_CONTEXT (block_impl->helper_func_decl) = NULL_TREE; - /* APPLE LOCAL end radar 6230297 */ - DECL_ARTIFICIAL (block_holder_tmp_decl) = 1; - - /* Create a CONSTRUCTOR to represent the braced-initializer. */ - constructor = make_node (CONSTRUCTOR); - - CONSTRUCTOR_ELTS (constructor) = build_block_struct_initlist (block_struct_type, - block_impl); - /* Temporary representing a global block is made global static. */ - /* APPLE LOCAL radar 6230297 */ - if (staticBlockTmp || global_bindings_p ()) { - TREE_PUBLIC (block_holder_tmp_decl) = 0; - TREE_STATIC (block_holder_tmp_decl) = 1; - } - cp_finish_decl (block_holder_tmp_decl, constructor, 0, 0, LOOKUP_ONLYCONVERTING); - return block_holder_tmp_decl; -} -/* APPLE LOCAL end radar 6169527 */ - -static tree -clean_and_exit (tree block) -{ - pop_function_context (); - pop_lang_context (); - if (current_function_decl) - free (finish_block (block)); - return error_mark_node; -} - -/** synth_copy_helper_block_func - This function synthesizes - void copy_helper_block (struct block* _dest, struct block *_src) function. -*/ - -static void -synth_copy_helper_block_func (struct block_sema_info * block_impl) -{ - tree stmt, chain; - tree dst_arg, src_arg; - /* struct c_arg_info * arg_info; */ - /* Set up: (struct block* _dest, struct block *_src) parameters. */ - dst_arg = build_decl (PARM_DECL, get_identifier ("_dst"), - block_impl->block_arg_ptr_type); - DECL_CONTEXT (dst_arg) = cur_block->copy_helper_func_decl; - TREE_USED (dst_arg) = 1; - DECL_ARG_TYPE (dst_arg) = block_impl->block_arg_ptr_type; - src_arg = build_decl (PARM_DECL, get_identifier ("_src"), - block_impl->block_arg_ptr_type); - DECL_CONTEXT (src_arg) = cur_block->copy_helper_func_decl; - TREE_USED (src_arg) = 1; - DECL_ARG_TYPE (src_arg) = block_impl->block_arg_ptr_type; - /* arg_info = xcalloc (1, sizeof (struct c_arg_info)); */ - TREE_CHAIN (dst_arg) = src_arg; - - pushdecl (cur_block->copy_helper_func_decl); - /* arg_info->parms = dst_arg; */ - /* arg_info->types = tree_cons (NULL_TREE, block_impl->block_arg_ptr_type, - tree_cons (NULL_TREE, - block_impl->block_arg_ptr_type, - NULL_TREE)); */ - DECL_ARGUMENTS (cur_block->copy_helper_func_decl) = dst_arg; - /* function header synthesis. */ - push_function_context (); - /* start_block_helper_function (cur_block->copy_helper_func_decl, true); */ - /* store_parm_decls (arg_info); */ - start_preparsed_function (cur_block->copy_helper_func_decl, - /*attrs*/NULL_TREE, - SF_PRE_PARSED); - - /* Body of the function. */ - stmt = begin_compound_stmt (BCS_FN_BODY); - for (chain = block_impl->block_ref_decl_list; chain; - chain = TREE_CHAIN (chain)) - /* APPLE LOCAL radar 6214617 */ - if (cp_block_requires_copying (TREE_VALUE (chain))) - { - /* APPLE LOCAL begin radar 6175959 */ - int flag = 0; - tree p = TREE_VALUE (chain); - tree dst_block_component, src_block_component; - dst_block_component = build_component_ref (build_indirect_ref (dst_arg, "->"), - DECL_NAME (p)); - src_block_component = build_component_ref (build_indirect_ref (src_arg, "->"), - DECL_NAME (p)); - - if (TREE_CODE (TREE_TYPE (p)) == BLOCK_POINTER_TYPE) - /* _Block_object_assign(&_dest->myImportedBlock, _src->myImportedClosure, BLOCK_FIELD_IS_BLOCK) */ - flag = BLOCK_FIELD_IS_BLOCK; - /* APPLE LOCAL begin radar 6214617 */ - else if (TYPE_HAS_CONSTRUCTOR (TREE_TYPE (p)) - || TYPE_NEEDS_CONSTRUCTING (TREE_TYPE (p))) - { - tree call_exp = build_aggr_init (dst_block_component, src_block_component, - LOOKUP_ONLYCONVERTING); - add_stmt (call_exp); - } - /* APPLE LOCAL end radar 6214617 */ - else - /* _Block_object_assign(&_dest->myImportedBlock, _src->myImportedClosure, BLOCK_FIELD_IS_OBJECT) */ - flag = BLOCK_FIELD_IS_OBJECT; - if (flag) - { - tree call_exp; - dst_block_component = build_fold_addr_expr (dst_block_component); - call_exp = build_block_object_assign_call_exp (dst_block_component, src_block_component, flag); - add_stmt (call_exp); - } - /* APPLE LOCAL end radar 6175959 */ - } - - /* For each __block declared variable used in |...| Must generate call to: - _Block_object_assign(&_dest->myImportedBlock, _src->myImportedBlock, BLOCK_FIELD_IS_BYREF [|BLOCK_FIELD_IS_WEAK]) - */ - for (chain = block_impl->block_byref_decl_list; chain; - chain = TREE_CHAIN (chain)) - if (COPYABLE_BYREF_LOCAL_VAR (TREE_VALUE (chain))) - { - int flag = BLOCK_FIELD_IS_BYREF; - tree call_exp; - tree p = TREE_VALUE (chain); - tree dst_block_component, src_block_component; - dst_block_component = build_component_ref (build_indirect_ref (dst_arg, "->"), - DECL_NAME (p)); - src_block_component = build_component_ref (build_indirect_ref (src_arg, "->"), - DECL_NAME (p)); - - /* _Block_object_assign(&_dest->myImportedClosure, _src->myImportedClosure, BLOCK_FIELD_IS_BYREF [|BLOCK_FIELD_IS_WEAK]) */ - if (COPYABLE_WEAK_BLOCK (p)) - flag |= BLOCK_FIELD_IS_WEAK; - - dst_block_component = build_fold_addr_expr (dst_block_component); - call_exp = build_block_object_assign_call_exp (dst_block_component, src_block_component, flag); - add_stmt (call_exp); - } - - finish_compound_stmt (stmt); - /* APPLE LOCAL radar 6169580 */ - finish_function (4); - /* Hum, would be nice if someone else did this for us. */ - if (global_bindings_p ()) - cgraph_finalize_function (block_impl->copy_helper_func_decl, false); - pop_function_context (); - /* free (arg_info); */ -} - -static void -synth_destroy_helper_block_func (struct block_sema_info * block_impl) -{ - tree stmt, chain; - tree src_arg; - /* struct c_arg_info * arg_info; */ - /* Set up: (struct block *_src) parameter. */ - src_arg = build_decl (PARM_DECL, get_identifier ("_src"), - block_impl->block_arg_ptr_type); - DECL_CONTEXT (src_arg) = cur_block->destroy_helper_func_decl; - TREE_USED (src_arg) = 1; - DECL_ARG_TYPE (src_arg) = block_impl->block_arg_ptr_type; - /* arg_info = xcalloc (1, sizeof (struct c_arg_info)); */ - - pushdecl (cur_block->destroy_helper_func_decl); - /* arg_info->parms = src_arg; */ - /* arg_info->types = tree_cons (NULL_TREE, block_impl->block_arg_ptr_type, - NULL_TREE); */ - DECL_ARGUMENTS (cur_block->destroy_helper_func_decl) = src_arg; - - /* function header synthesis. */ - push_function_context (); - /* start_block_helper_function (cur_block->destroy_helper_func_decl, true); */ - /* store_parm_decls_from (arg_info); */ - start_preparsed_function (cur_block->destroy_helper_func_decl, - /*attrs*/NULL_TREE, - SF_PRE_PARSED); - - /* Body of the function. */ - stmt = begin_compound_stmt (BCS_FN_BODY); - for (chain = block_impl->block_ref_decl_list; chain; - chain = TREE_CHAIN (chain)) - /* APPLE LOCAL begin radar 6214617 */ - if (block_requires_copying (TREE_VALUE (chain)) - || (TREE_CODE (TREE_TYPE (TREE_VALUE (chain))) == RECORD_TYPE - && CLASSTYPE_DESTRUCTORS (TREE_TYPE (TREE_VALUE (chain))))) - /* APPLE LOCAL end radar 6214617 */ - { - int flag = 0; - tree rel_exp; - tree p = TREE_VALUE (chain); - tree src_block_component; - src_block_component = build_component_ref (build_indirect_ref (src_arg, "->"), - DECL_NAME (p)); - - if (TREE_CODE (TREE_TYPE (p)) == BLOCK_POINTER_TYPE) - /* _Block_object_dispose(_src->imported_object_0, BLOCK_FIELD_IS_BLOCK); */ - flag = BLOCK_FIELD_IS_BLOCK; - /* APPLE LOCAL begin radar 6214617 */ - else if (TREE_CODE (TREE_TYPE (p)) == RECORD_TYPE - && CLASSTYPE_DESTRUCTORS (TREE_TYPE (p))) - { - tree call_exp = cxx_maybe_build_cleanup (src_block_component); - gcc_assert (call_exp); - add_stmt (call_exp); - } - /* APPLE LOCAL end radar 6214617 */ - else - /* _Block_object_dispose(_src->imported_object_0, BLOCK_FIELD_IS_OBJECT); */ - flag = BLOCK_FIELD_IS_OBJECT; - if (flag) - { - rel_exp = build_block_object_dispose_call_exp (src_block_component, flag); - add_stmt (rel_exp); - } - } - - /* For each __block declared variable used in |...| Must generate call to: - _Block_object_dispose(_src->myImportedClosure, BLOCK_FIELD_IS_BYREF[|BLOCK_FIELD_IS_WEAK]) - */ - for (chain = block_impl->block_byref_decl_list; chain; - chain = TREE_CHAIN (chain)) - if (COPYABLE_BYREF_LOCAL_VAR (TREE_VALUE (chain))) - { - tree call_exp; - int flag = BLOCK_FIELD_IS_BYREF; - tree p = TREE_VALUE (chain); - tree src_block_component; - - src_block_component = build_component_ref (build_indirect_ref (src_arg, "->"), - DECL_NAME (p)); - if (COPYABLE_WEAK_BLOCK (p)) - flag |= BLOCK_FIELD_IS_WEAK; - /* _Block_object_dispose(_src->myImportedClosure, BLOCK_FIELD_IS_BYREF[|BLOCK_FIELD_IS_WEAK]) */ - call_exp = build_block_object_dispose_call_exp (src_block_component, flag); - add_stmt (call_exp); - } - - finish_compound_stmt (stmt); - /* APPLE LOCAL radar 6169580 */ - finish_function (4); - /* Hum, would be nice if someone else did this for us. */ - if (global_bindings_p ()) - cgraph_finalize_function (block_impl->destroy_helper_func_decl, false); - pop_function_context (); -} - -/* Parse a block-id. - - GNU Extension: - - block-id: - type-specifier-seq block-declarator - - Returns the DECL specified or implied. */ - -static tree -cp_parser_block_id (cp_parser* parser) -{ - cp_decl_specifier_seq type_specifier_seq; - cp_declarator *declarator; - - /* Parse the type-specifier-seq. */ - cp_parser_type_specifier_seq (parser, /*is_condition=*/false, - &type_specifier_seq); - if (type_specifier_seq.type == error_mark_node) - return error_mark_node; - - /* Look for the block-declarator. */ - declarator - = cp_parser_declarator (parser, CP_PARSER_DECLARATOR_BLOCK, NULL, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - - return grokblockdecl (&type_specifier_seq, declarator); -} - -/* Parse a block-literal-expr. - - GNU Extension: - - block-literal-expr: - ^ parameter-declation-clause exception-specification [opt] compound-statement - ^ block-id compound-statement - - It synthesizes the helper function for later generation and builds - the necessary data to represent the block literal where it is - declared. */ -static tree -cp_parser_block_literal_expr (cp_parser* parser) -{ - char name [32]; - static int global_unique_count; - int unique_count = ++global_unique_count; - tree block_helper_function_decl; - tree expr, type, arglist = NULL_TREE, ftype; - tree self_arg, stmt; - /* struct c_arg_info *args = NULL; */ - cp_parameter_declarator *args = NULL; - tree arg_type = void_list_node; - struct block_sema_info *block_impl; - tree tmp; - tree restype; - tree typelist; - tree helper_function_type; - tree block; - /* APPLE LOCAL radar 6185344 */ - tree declared_block_return_type = NULL_TREE; - /* APPLE LOCAL radar 6237713 */ - tree attributes = NULL_TREE; - /* APPLE LOCAL radar 6169580 */ - int context_is_nonstatic_method; - tree raises = NULL_TREE; - - cp_lexer_consume_token (parser->lexer); /* eat '^' */ - - /* APPLE LOCAL begin radar 6237713 */ - if (cp_lexer_peek_token (parser->lexer)->keyword == RID_ATTRIBUTE) - attributes = cp_parser_attributes_opt (parser); - /* APPLE LOCAL end radar 6237713 */ - - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - { - /* Parse the optional argument list */ - cp_lexer_consume_token (parser->lexer); - /* Open the scope to collect parameter decls */ - /* push_scope (); */ - /* args = c_parser_parms_declarator (parser, true, NULL_TREE); */ - /* Parse the parameter-declaration-clause. */ - args = cp_parser_parameter_declaration_clause (parser); - cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'"); - arg_type = grokparms (args, &arglist); - /* Check for args as it might be NULL due to error. */ - if (! args) - { - return error_mark_node; - } - raises = cp_parser_exception_specification_opt (parser); - } - /* APPLE LOCAL begin radar 6185344 */ - else if (cp_lexer_next_token_is_not (parser->lexer, CPP_OPEN_BRACE)) - { - /* Parse user declared return type. */ - tree decl; - - /* APPLE LOCAL begin radar 6237713 */ - if (attributes) - { - warning (0, "attributes before block type are ignored"); - attributes = NULL_TREE; - } - /* APPLE LOCAL end radar 6237713 */ - - decl = cp_parser_block_id (parser); - - if (decl && decl != error_mark_node) - { - arg_type = TYPE_ARG_TYPES (TREE_TYPE (decl)); - arglist = DECL_ARGUMENTS (decl); - raises = TYPE_RAISES_EXCEPTIONS (TREE_TYPE (decl)); - declared_block_return_type = TREE_TYPE (TREE_TYPE (decl)); - } - } - /* APPLE LOCAL end radar 6185344 */ - - block = begin_block (); - /* APPLE LOCAL begin radar 6169580 */ - context_is_nonstatic_method = (current_function_decl - && DECL_NONSTATIC_MEMBER_FUNCTION_P (current_function_decl)); - /* APPLE LOCAL end radar 6169580 */ - - /* cur_block->arg_info = NULL; */ - /* APPLE LOCAL begin radar 6185344 */ - if (declared_block_return_type) - { - cur_block->return_type = TYPE_MAIN_VARIANT (declared_block_return_type); - cur_block->block_has_return_type = true; - } - else - cur_block->return_type = NULL_TREE; - /* APPLE LOCAL end radar 6185344 */ - - /* Must also build hidden parameter .block_descriptor added to the helper - function, even though we do not know its type yet. */ - /* APPLE LOCAL radar 6404979 */ - self_arg = build_artificial_parm (get_identifier (".block_descriptor"), ptr_type_node); - - /* TREE_CHAIN (self_arg) = cur_block->arg_info->parms; */ - TREE_CHAIN (self_arg) = arglist; - arg_type = tree_cons (NULL_TREE, ptr_type_node, arg_type); - arglist = self_arg; - - /* APPLE LOCAL begin radar 6185344 */ - /* Build the declaration of the helper function (if we do not know its result - type yet, assume it is 'void'. If user provided it, use it). - Treat this as a nested function and use nested function infrastructure for - its generation. */ - - push_lang_context (lang_name_c); - - ftype = build_function_type ((!cur_block->block_has_return_type - ? void_type_node : cur_block->return_type), - arg_type); - /* APPLE LOCAL end radar 6185344 */ - if (raises) - ftype = build_exception_variant (ftype, raises); - /* APPLE LOCAL radar 6160536 */ - block_helper_function_decl = build_helper_func_decl (build_block_helper_name (unique_count), - ftype); - DECL_CONTEXT (block_helper_function_decl) = current_function_decl; - cur_block->helper_func_decl = block_helper_function_decl; - - DECL_ARGUMENTS (block_helper_function_decl) = arglist; - - push_function_context (); - /* start_block_helper_function (cur_block->helper_func_decl, false); */ - /* Enter parameter list to the scope of the helper function. */ - /* store_parm_decls_from (cur_block->arg_info); */ - start_preparsed_function (cur_block->helper_func_decl, - /*attrs*/NULL_TREE, - SF_PRE_PARSED); - /* APPLE LOCAL begin radar 6237713 */ - if (cp_lexer_peek_token (parser->lexer)->keyword == RID_ATTRIBUTE) - attributes = cp_parser_attributes_opt (parser); - /* APPLE LOCAL radar 6246527 */ - any_recognized_block_attribute (attributes); - decl_attributes (&cur_block->helper_func_decl, attributes, 0); - /* APPLE LOCAL end radar 6237713 */ - - /* Start parsing body or expression part of the block literal. */ - { - unsigned save = parser->in_statement; - /* Indicate no valid break/continue context. We'll notice and - emit the proper error message in c_finish_bc_stmt. */ - parser->in_statement = 0; - stmt = begin_compound_stmt (BCS_FN_BODY); - /* Set block's scope to the scope of the helper function's main body. - This is primarily used when nested blocks are declared. */ - cur_block->cp_the_scope = current_binding_level; - /* APPLE LOCAL begin radar 6169580 */ - if (context_is_nonstatic_method) - { - tree this_decl = lookup_name (this_identifier); - gcc_assert (this_decl); - build_block_ref_decl (this_identifier, this_decl); - } - /* APPLE LOCAL end radar 6169580 */ - cp_parser_compound_statement (parser, NULL, false, false); - parser->in_statement = save; - } - - cur_block->block_arg_ptr_type = - build_pointer_type (build_block_struct_type (cur_block)); - - restype = !cur_block->return_type ? void_type_node - : cur_block->return_type; - if (restype == error_mark_node) - return clean_and_exit (block); - - /* Now that we know type of the hidden .block_descriptor argument, fix its type. */ - TREE_TYPE (self_arg) = cur_block->block_arg_ptr_type; - DECL_ARG_TYPE (self_arg) = cur_block->block_arg_ptr_type; - - /* The DECL_RESULT should already have the correct type by now. */ - gcc_assert (TREE_TYPE (DECL_RESULT (current_function_decl)) - == restype); - - cur_block->block_body = stmt; - block_build_prologue (cur_block); - - finish_compound_stmt (stmt); - /* add_stmt (fnbody); */ - - /* We are done parsing of the block body. Return type of block is now known. - We also know all we need to know about the helper function. So, fix its - type here. */ - /* We moved this here because for global blocks, helper function body is - not nested and is gimplified in call to finish_function() and return type - of the function must be correct. */ - ftype = build_function_type (restype, TREE_CHAIN (arg_type)); - if (raises) - ftype = build_exception_variant (ftype, raises); - /* Declare helper function; as in: - double helper_1(struct block_1 *ii, int z); */ - typelist = TYPE_ARG_TYPES (ftype); - /* (struct block_1 *ii, int z, ...) */ - typelist = tree_cons (NULL_TREE, cur_block->block_arg_ptr_type, - typelist); - helper_function_type = build_function_type (TREE_TYPE (ftype), typelist); - if (raises) - helper_function_type = build_exception_variant (helper_function_type, raises); - TREE_TYPE (cur_block->helper_func_decl) = helper_function_type; - finish_function (4); - pop_function_context (); - /* Hum, would be nice if someone else did this for us. */ - if (global_bindings_p ()) - cgraph_finalize_function (cur_block->helper_func_decl, false); - pop_lang_context (); - - /* Build the declaration for copy_helper_block and destroy_helper_block - helper functions for later use. */ - - if (cur_block->BlockHasCopyDispose) - { - tree s_ftype; - - push_lang_context (lang_name_c); - /* void copy_helper_block (struct block*, struct block *); */ - s_ftype = build_function_type (void_type_node, - tree_cons (NULL_TREE, cur_block->block_arg_ptr_type, - tree_cons (NULL_TREE, - cur_block->block_arg_ptr_type, - void_list_node))); - sprintf (name, "__copy_helper_block_%d", unique_count); - cur_block->copy_helper_func_decl = - build_helper_func_decl (get_identifier (name), s_ftype); - DECL_CONTEXT (cur_block->copy_helper_func_decl) = current_function_decl; - synth_copy_helper_block_func (cur_block); - - /* void destroy_helper_block (struct block*); */ - s_ftype = build_function_type (void_type_node, - tree_cons (NULL_TREE, - cur_block->block_arg_ptr_type, void_list_node)); - sprintf (name, "__destroy_helper_block_%d", unique_count); - cur_block->destroy_helper_func_decl = - build_helper_func_decl (get_identifier (name), s_ftype); - DECL_CONTEXT (cur_block->destroy_helper_func_decl) = current_function_decl; - synth_destroy_helper_block_func (cur_block); - pop_lang_context (); - } - - block_impl = finish_block (block); - - /* Build unqiue name of the temporary used in code gen. */ - sprintf (name, "__block_holder_tmp_%d", unique_count); - tmp = build_block_literal_tmp (name, block_impl); - tmp = build_fold_addr_expr (tmp); - type = build_block_pointer_type (ftype); - expr = convert (type, convert (ptr_type_node, tmp)); - free (block_impl); - return expr; -} -/* APPLE LOCAL end blocks 6040305 (ce) */ - -/* APPLE LOCAL begin blocks 6040305 (ch) */ -/* build_byref_local_var_access - converts EXPR to: - EXPR.__forwarding-><decl-name>. -*/ -tree -build_byref_local_var_access (tree expr, tree decl_name) -{ - tree exp = build_component_ref (expr, get_identifier ("__forwarding")); - exp = build_indirect_ref (exp, "unary *"); - exp = build_component_ref (exp, decl_name); - return exp; -} - -#define BINDING_VALUE(b) ((b)->value) - -/** - build_block_byref_decl - This routine inserts a variable declared as a - 'byref' variable using the |...| syntax in helper function's outer-most scope. -*/ -tree -build_block_byref_decl (tree name, tree decl, tree exp) -{ - tree ptr_type, byref_decl; - /* APPLE LOCAL begin radar 6225809 */ - if (cur_block->prev_block_info) { - /* Traverse enclosing blocks. Insert a __block variable in - each enclosing block which has no declaration of this - variable. This is to ensure that the current (inner) block - gets the __block version of the variable; */ - struct block_sema_info *cb = cur_block->prev_block_info; - while (cb) { - struct cxx_binding *b = I_SYMBOL_BINDING (name); - gcc_assert (b); - gcc_assert (BINDING_VALUE (b)); - gcc_assert (TREE_CODE (BINDING_VALUE (b)) == VAR_DECL - || TREE_CODE (BINDING_VALUE (b)) == PARM_DECL); - /* Find the first declaration not in current block. */ - while (b && BINDING_VALUE (b) - && (TREE_CODE (BINDING_VALUE (b)) == VAR_DECL - || TREE_CODE (BINDING_VALUE (b)) == PARM_DECL) - && DECL_CONTEXT (BINDING_VALUE (b)) == cur_block->helper_func_decl) - { - /* FIXME: This can't happen?! */ - abort (); - /* b = b->previous; */ - } - - gcc_assert (b); - gcc_assert (BINDING_VALUE (b)); - gcc_assert (TREE_CODE (BINDING_VALUE (b)) == VAR_DECL - || TREE_CODE (BINDING_VALUE (b)) == PARM_DECL); - - /* Is the next declaration not in the enclosing block? */ - if (b && BINDING_VALUE (b) - && (TREE_CODE (BINDING_VALUE (b)) == VAR_DECL - || TREE_CODE (BINDING_VALUE (b)) == PARM_DECL) - && DECL_CONTEXT (BINDING_VALUE (b)) != cb->helper_func_decl) - { - /* No declaration of variable seen in the block. Must insert one. */ - /* FIXME: does this push enough? scope? */ - struct cp_binding_level *save_scope = current_binding_level; - struct block_sema_info *save_current_block = cur_block; - tree save_current_function_decl = current_function_decl; - current_binding_level = cb->cp_the_scope; - cur_block = cb; - current_function_decl = cb->helper_func_decl; - decl = build_block_byref_decl (name, decl, exp); - cur_block = save_current_block; - current_binding_level = save_scope; - current_function_decl = save_current_function_decl; - } - cb = cb->prev_block_info; - } - } - /* APPLE LOCAL end radar 6225809 */ - - /* If it is already a byref declaration, do not add the pointer type - because such declarations already have the pointer type - added. This happens when we have two nested byref declarations in - nested blocks. */ - ptr_type = (TREE_CODE (decl) == VAR_DECL && BLOCK_DECL_BYREF (decl)) - ? TREE_TYPE (decl) : build_pointer_type (TREE_TYPE (decl)); - byref_decl = build_decl (VAR_DECL, name, ptr_type); - DECL_CONTEXT (byref_decl) = current_function_decl; - BLOCK_DECL_BYREF (byref_decl) = 1; - - if (TREE_CODE (decl) == VAR_DECL && COPYABLE_BYREF_LOCAL_VAR (decl)) - { - COPYABLE_BYREF_LOCAL_VAR (byref_decl) = 1; - COPYABLE_BYREF_LOCAL_NONPOD (byref_decl) = COPYABLE_BYREF_LOCAL_NONPOD (decl); - /* APPLE LOCAL radar 5847976 */ - COPYABLE_WEAK_BLOCK (byref_decl) = COPYABLE_WEAK_BLOCK (decl); - } - - /* Current scope must be that of the main function body. */ - /* FIXME gcc_assert (current_scope->function_body);*/ - pushdecl (byref_decl); - mark_used (byref_decl); - /* APPLE LOCAL begin radar 6083129 - byref escapes (cp) */ - /* FIXME: finish this off, ensure the decl is scoped appropriately - for when we want the cleanup to run. */ - if (! flag_objc_gc_only) - push_cleanup (byref_decl, build_block_byref_release_exp (byref_decl), false); - /* APPLE LOCAL end radar 6083129 - byref escapes (cp) */ - cur_block->block_byref_decl_list = - tree_cons (NULL_TREE, byref_decl, cur_block->block_byref_decl_list); - /* APPLE LOCAL radar 5847213 */ - /* build of block_original_byref_decl_list us removed. */ - /* APPLE LOCAL begin radar 6144664 */ - DECL_SOURCE_LOCATION (byref_decl) - = DECL_SOURCE_LOCATION (cur_block->helper_func_decl); - /* APPLE LOCAL end radar 6144664 */ - return byref_decl; -} - -/** - build_block_ref_decl - This routine inserts a copied-in variable (a variable - referenced in the block but whose scope is outside the block) in helper - function's outer-most scope. It also sets its type to 'const' as such - variables are read-only. -*/ -tree -build_block_ref_decl (tree name, tree decl) -{ - /* FIXME - Broken, should be found via objc runtime testcases. */ - /* FIXME - Don't use DECL_CONTEXT on any helpers */ - tree ref_decl; - /* APPLE LOCAL radar 6212722 */ - tree type, exp; - /* 'decl' was previously declared as __block. Simply, copy the value - embedded in the above variable. */ - if (TREE_CODE (decl) == VAR_DECL && COPYABLE_BYREF_LOCAL_VAR (decl)) - decl = build_byref_local_var_access (decl, DECL_NAME (decl)); - else { - if (cur_block->prev_block_info) { - /* Traverse enclosing blocks. Insert a copied-in variable in - each enclosing block which has no declaration of this - variable. This is to ensure that the current (inner) block - has the 'frozen' value of the copied-in variable; which means - the value of the copied in variable is at the point of the - block declaration and *not* when the inner block is - invoked. */ - struct block_sema_info *cb = cur_block->prev_block_info; - while (cb) { - struct cxx_binding *b = I_SYMBOL_BINDING (name); - gcc_assert (b); - gcc_assert (BINDING_VALUE (b)); - gcc_assert (TREE_CODE (BINDING_VALUE (b)) == VAR_DECL - || TREE_CODE (BINDING_VALUE (b)) == PARM_DECL); - /* Find the first declaration not in current block. */ - while (b && BINDING_VALUE (b) - && (TREE_CODE (BINDING_VALUE (b)) == VAR_DECL - || TREE_CODE (BINDING_VALUE (b)) == PARM_DECL) - && DECL_CONTEXT (BINDING_VALUE (b)) == cur_block->helper_func_decl) - { - /* FIXME: This can't happen?! */ - abort (); - /* b = b->previous; */ - } - - gcc_assert (b); - gcc_assert (BINDING_VALUE (b)); - gcc_assert (TREE_CODE (BINDING_VALUE (b)) == VAR_DECL - || TREE_CODE (BINDING_VALUE (b)) == PARM_DECL); - - /* Is the next declaration not in the enclosing block? */ - if (b && BINDING_VALUE (b) - && (TREE_CODE (BINDING_VALUE (b)) == VAR_DECL - || TREE_CODE (BINDING_VALUE (b)) == PARM_DECL) - && DECL_CONTEXT (BINDING_VALUE (b)) != cb->helper_func_decl) - { - /* No declaration of variable seen in the block. Must - insert one, so it 'freezes' the variable in this - block. */ - /* FIXME: does this push enough? scope? */ - struct cp_binding_level *save_scope = current_binding_level; - struct block_sema_info *save_current_block = cur_block; - tree save_current_function_decl = current_function_decl; - current_binding_level = cb->cp_the_scope; - cur_block = cb; - current_function_decl = cb->helper_func_decl; - decl = build_block_ref_decl (name, decl); - cur_block = save_current_block; - current_binding_level = save_scope; - current_function_decl = save_current_function_decl; - } - cb = cb->prev_block_info; - } - } - } - /* APPLE LOCAL begin radar 6212722 */ - exp = decl; - type = TREE_TYPE (exp); - if (TREE_CODE (type) == ARRAY_TYPE || TREE_CODE (type) == FUNCTION_TYPE) { - exp = decay_conversion (exp); - type = TREE_TYPE (exp); - } - ref_decl = build_decl (VAR_DECL, name, - build_qualified_type (type, TYPE_QUAL_CONST)); - /* APPLE LOCAL end radar 6212722 */ - /* APPLE LOCAL begin radar 6144664 */ - DECL_SOURCE_LOCATION (ref_decl) = DECL_SOURCE_LOCATION - (cur_block->helper_func_decl); - /* APPLE LOCAL end radar 6144664 */ - DECL_CONTEXT (ref_decl) = current_function_decl; - DECL_INITIAL (ref_decl) = error_mark_node; - c_apply_type_quals_to_decl (TYPE_QUAL_CONST, ref_decl); - BLOCK_DECL_COPIED (ref_decl) = 1; - - /* Find the scope for function body (outer-most scope) and insert - this variable in that scope. This is to avoid duplicate - declaration of the save variable. */ - { - struct cp_binding_level *b = current_binding_level; - while (b->level_chain->kind != sk_function_parms) - b = b->level_chain; - pushdecl_with_scope (ref_decl, b, /*is_friend=*/false); - /* APPLE LOCAL radar 6169527 */ - add_decl_expr (ref_decl); - } - cur_block->block_ref_decl_list = - tree_cons (NULL_TREE, ref_decl, cur_block->block_ref_decl_list); - cur_block->block_original_ref_decl_list = - /* APPLE LOCAL radar 6212722 */ - tree_cons (NULL_TREE, exp, cur_block->block_original_ref_decl_list); - return ref_decl; -} - -/* APPLE LOCAL begin radar 5847213 - radar 6329245 */ -static GTY (()) tree descriptor_ptr_type; -static GTY (()) tree descriptor_ptr_type_with_copydispose; -/** build_block_descriptor_type - This routine builds following internal type: - struct __block_descriptor { - unsigned long int reserved; // NULL - unsigned long int Size; // sizeof(struct Block_literal_1) - - // optional helper functions - void *CopyFuncPtr; // When BLOCK_HAS_COPY_DISPOSE is set (withCopyDispose true) - void *DestroyFuncPtr; // When BLOCK_HAS_COPY_DISPOSE is set (withCopyDispose true) -} *descriptor_ptr_type; - -Objects of this type will always be static. This is one main component of abi change. -*/ -tree -build_block_descriptor_type (bool withCopyDispose) -{ - tree field_decl_chain = NULL_TREE, field_decl; - tree main_type; - - if (withCopyDispose && descriptor_ptr_type_with_copydispose) - return descriptor_ptr_type_with_copydispose; - if (!withCopyDispose && descriptor_ptr_type) - return descriptor_ptr_type; - - main_type = make_aggr_type (RECORD_TYPE); - xref_basetypes (main_type, NULL_TREE); - - /* unsigned long int reserved; */ - field_decl = build_decl (FIELD_DECL, get_identifier ("reserved"), long_unsigned_type_node); - TREE_CHAIN (field_decl) = field_decl_chain; - field_decl_chain = field_decl; - - /* unsigned long int Size; */ - field_decl = build_decl (FIELD_DECL, get_identifier ("Size"), long_unsigned_type_node); - TREE_CHAIN (field_decl) = field_decl_chain; - field_decl_chain = field_decl; - - if (withCopyDispose) - { - /* void *CopyFuncPtr; */ - field_decl = build_decl (FIELD_DECL, get_identifier ("CopyFuncPtr"), ptr_type_node); - TREE_CHAIN (field_decl) = field_decl_chain; - field_decl_chain = field_decl; - /* void *DestroyFuncPtr; */ - field_decl = build_decl (FIELD_DECL, get_identifier ("DestroyFuncPtr"), ptr_type_node); - TREE_CHAIN (field_decl) = field_decl_chain; - field_decl_chain = field_decl; - } - - /* Mark this struct as being a block struct rather than a 'normal' - struct. */ - TYPE_BLOCK_IMPL_STRUCT (main_type) = 1; - if (withCopyDispose) - finish_builtin_struct (main_type, "__block_descriptor_withcopydispose", field_decl_chain, NULL_TREE); - else - finish_builtin_struct (main_type, "__block_descriptor", field_decl_chain, NULL_TREE); - CLASSTYPE_AS_BASE (main_type) = main_type; - - main_type = build_pointer_type (main_type); - if (withCopyDispose) - descriptor_ptr_type_with_copydispose = main_type; - else - descriptor_ptr_type = main_type; - return main_type; -} -/* APPLE LOCAL end radar 5847213 - radar 6329245 */ - -cp_declarator * -make_block_pointer_declarator (tree attributes, - cp_cv_quals quals, - cp_declarator *target) -{ - struct cp_declarator *itarget = target; - struct cp_declarator *ret = make_declarator (cdk_block_pointer); - - /* APPLE LOCAL radar 5847213 */ - /* code removed */ - - - ret->attributes = attributes; - ret->declarator = itarget; - ret->u.block_pointer.qualifiers = quals; - return ret; -} - -/* This routine returns 'true' if 'name' has a declaration inside the - current block, 'false' otherwise. If 'name' has no declaration in - the current block, it returns in DECL the user declaration for - 'name' found in the enclosing scope. Note that if it is declared - in current declaration, it can be either a user declaration or a - byref/copied-in declaration added in current block's scope by the - compiler. */ -bool -lookup_name_in_block (tree name, tree *decl) -{ - /* FIXME - Broken, should be found via objc runtime testcases. */ - /* FIXME - Don't use DECL_CONTEXT on any helpers */ - cxx_binding *b = I_SYMBOL_BINDING (name); - if (b && b->declared_in_block - && DECL_CONTEXT (BINDING_VALUE (b)) == current_function_decl) - return true; - - /* Check for variables only, as we may have parameters, such as - 'self' */ - /* Note that if a copied-in variable (BLOCK_DECL_COPIED) in the - enclosing block is found, it must be returned as this is - where the variable in current (nested block) will have to get - its value. */ - while (b - && TREE_CODE (BINDING_VALUE (b)) == VAR_DECL - && (BLOCK_DECL_BYREF (BINDING_VALUE (b)))) - b = b->previous; - if (b) - *decl = BINDING_VALUE (b); - return false; -} - -/** - build_helper_func_decl - This routine builds a FUNCTION_DECL for - a block helper function. -*/ -tree -build_helper_func_decl (tree ident, tree type) -{ - tree func_decl = build_decl (FUNCTION_DECL, ident, type); - DECL_EXTERNAL (func_decl) = 0; - TREE_PUBLIC (func_decl) = 0; - TREE_USED (func_decl) = 1; - TREE_NOTHROW (func_decl) = 0; - /* APPLE LOCAL radar 6172148 */ - BLOCK_SYNTHESIZED_FUNC (func_decl) = 1; - retrofit_lang_decl (func_decl); - if (current_function_decl) - DECL_NO_STATIC_CHAIN (current_function_decl) = 0; - return func_decl; -} - -/** - declare_block_prologue_local_vars - utility routine to do the actual - declaration and initialization for each referecned block variable. -*/ -/* APPLE LOCAL begin radar 6169527 */ -/* This routine is mostly rewritten for c++ because initialization of variables - may involve copy construction. */ -static void -declare_block_prologue_local_vars (tree self_parm, tree component, - tree stmt) -{ - tree decl, block_component; - tree_stmt_iterator i; - tree initialization_stmt; - /* APPLE LOCAL radar 6163705 */ - int save_line = LOCATION_LINE (input_location); - - decl = component; - block_component = build_component_ref (build_indirect_ref (self_parm, "->"), - DECL_NAME (component)); - gcc_assert (block_component); - /* APPLE LOCAL radar 6163705 */ - LOCATION_LINE (input_location) = DECL_SOURCE_LINE (decl) - 1; - DECL_EXTERNAL (decl) = 0; - TREE_STATIC (decl) = 0; - TREE_USED (decl) = 1; - DECL_CONTEXT (decl) = current_function_decl; - DECL_ARTIFICIAL (decl) = 1; - initialization_stmt = push_stmt_list(); - cp_finish_decl (decl, block_component, 0, 0, LOOKUP_ONLYCONVERTING); - initialization_stmt = pop_stmt_list (initialization_stmt); - /* APPLE LOCAL radar 6163705 */ - LOCATION_LINE (input_location) = save_line; - /* Prepend a initialization_stmt statement to the statement list. */ - i = tsi_start (stmt); - tsi_link_before (&i, initialization_stmt, TSI_SAME_STMT); -} - -/** - declare_block_prologue_local_byref_vars - utility routine to do the actual - declaration and initialization for each __block referenced block variable. - */ -static void -declare_block_prologue_local_byref_vars (tree self_parm, tree component, - tree stmt) -{ - tree decl, block_component; - tree_stmt_iterator i; - tree decl_stmt; - - decl = component; - block_component = build_component_ref (build_indirect_ref (self_parm, "->"), - DECL_NAME (component)); - gcc_assert (block_component); - DECL_EXTERNAL (decl) = 0; - TREE_STATIC (decl) = 0; - TREE_USED (decl) = 1; - DECL_CONTEXT (decl) = current_function_decl; - DECL_ARTIFICIAL (decl) = 1; - DECL_INITIAL (decl) = block_component; - /* Prepend a DECL_EXPR statement to the statement list. */ - i = tsi_start (stmt); - decl_stmt = build_stmt (DECL_EXPR, decl); - SET_EXPR_LOCATION (decl_stmt, DECL_SOURCE_LOCATION (decl)); - /* APPLE LOCAL begin radar 6163705, Blocks prologues */ - /* Give the prologue statements a line number of one before the beginning of - the function, to make them easily identifiable later. */ - EXPR_LINENO (decl_stmt) = DECL_SOURCE_LINE (decl) - 1; - /* APPLE LOCAL end radar 6163705, Blocks prologues */ - decl_stmt = build3 (BIND_EXPR, void_type_node, decl, decl_stmt, NULL); - TREE_SIDE_EFFECTS (decl_stmt) = 1; - - tsi_link_before (&i, decl_stmt, TSI_SAME_STMT); -} -/* APPLE LOCAL end radar 6169527 */ - -/** - block_build_prologue - - This routine builds the declarations for the - variables referenced in the block; as in: - int *y = .block_descriptor->y; - int x = .block_descriptor->x; - - The decl_expr declaration for each initialization is enterred at the - beginning of the helper function's statement-list which is passed - in block_impl->block_body. -*/ -void -block_build_prologue (struct block_sema_info *block_impl) -{ - tree chain; - tree self_parm = lookup_name (get_identifier (".block_descriptor")); - gcc_assert (self_parm); - - for (chain = block_impl->block_ref_decl_list; chain; - chain = TREE_CHAIN (chain)) - declare_block_prologue_local_vars (self_parm, TREE_VALUE (chain), - block_impl->block_body); - /* APPLE LOCAL begin radar 6169527 */ - for (chain = block_impl->block_byref_decl_list; chain; - chain = TREE_CHAIN (chain)) - declare_block_prologue_local_byref_vars (self_parm, TREE_VALUE (chain), - block_impl->block_body); - /* APPLE LOCAL end radar 6169527 */ -} -/* APPLE LOCAL end blocks 6040305 (ch) */ - -/* OpenMP 2.5 parsing routines. */ - -/* All OpenMP clauses. OpenMP 2.5. */ -typedef enum pragma_omp_clause { - PRAGMA_OMP_CLAUSE_NONE = 0, - - PRAGMA_OMP_CLAUSE_COPYIN, - PRAGMA_OMP_CLAUSE_COPYPRIVATE, - PRAGMA_OMP_CLAUSE_DEFAULT, - PRAGMA_OMP_CLAUSE_FIRSTPRIVATE, - PRAGMA_OMP_CLAUSE_IF, - PRAGMA_OMP_CLAUSE_LASTPRIVATE, - PRAGMA_OMP_CLAUSE_NOWAIT, - PRAGMA_OMP_CLAUSE_NUM_THREADS, - PRAGMA_OMP_CLAUSE_ORDERED, - PRAGMA_OMP_CLAUSE_PRIVATE, - PRAGMA_OMP_CLAUSE_REDUCTION, - PRAGMA_OMP_CLAUSE_SCHEDULE, - PRAGMA_OMP_CLAUSE_SHARED -} pragma_omp_clause; - -/* Returns name of the next clause. - If the clause is not recognized PRAGMA_OMP_CLAUSE_NONE is returned and - the token is not consumed. Otherwise appropriate pragma_omp_clause is - returned and the token is consumed. */ - -static pragma_omp_clause -cp_parser_omp_clause_name (cp_parser *parser) -{ - pragma_omp_clause result = PRAGMA_OMP_CLAUSE_NONE; - - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_IF)) - result = PRAGMA_OMP_CLAUSE_IF; - else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_DEFAULT)) - result = PRAGMA_OMP_CLAUSE_DEFAULT; - else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_PRIVATE)) - result = PRAGMA_OMP_CLAUSE_PRIVATE; - else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - { - tree id = cp_lexer_peek_token (parser->lexer)->u.value; - const char *p = IDENTIFIER_POINTER (id); - - switch (p[0]) - { - case 'c': - if (!strcmp ("copyin", p)) - result = PRAGMA_OMP_CLAUSE_COPYIN; - else if (!strcmp ("copyprivate", p)) - result = PRAGMA_OMP_CLAUSE_COPYPRIVATE; - break; - case 'f': - if (!strcmp ("firstprivate", p)) - result = PRAGMA_OMP_CLAUSE_FIRSTPRIVATE; - break; - case 'l': - if (!strcmp ("lastprivate", p)) - result = PRAGMA_OMP_CLAUSE_LASTPRIVATE; - break; - case 'n': - if (!strcmp ("nowait", p)) - result = PRAGMA_OMP_CLAUSE_NOWAIT; - else if (!strcmp ("num_threads", p)) - result = PRAGMA_OMP_CLAUSE_NUM_THREADS; - break; - case 'o': - if (!strcmp ("ordered", p)) - result = PRAGMA_OMP_CLAUSE_ORDERED; - break; - case 'r': - if (!strcmp ("reduction", p)) - result = PRAGMA_OMP_CLAUSE_REDUCTION; - break; - case 's': - if (!strcmp ("schedule", p)) - result = PRAGMA_OMP_CLAUSE_SCHEDULE; - else if (!strcmp ("shared", p)) - result = PRAGMA_OMP_CLAUSE_SHARED; - break; - } - } - - if (result != PRAGMA_OMP_CLAUSE_NONE) - cp_lexer_consume_token (parser->lexer); - - return result; -} - -/* Validate that a clause of the given type does not already exist. */ - -static void -check_no_duplicate_clause (tree clauses, enum tree_code code, const char *name) -{ - tree c; - - for (c = clauses; c ; c = OMP_CLAUSE_CHAIN (c)) - if (OMP_CLAUSE_CODE (c) == code) - { - error ("too many %qs clauses", name); - break; - } -} - -/* OpenMP 2.5: - variable-list: - identifier - variable-list , identifier - - In addition, we match a closing parenthesis. An opening parenthesis - will have been consumed by the caller. - - If KIND is nonzero, create the appropriate node and install the decl - in OMP_CLAUSE_DECL and add the node to the head of the list. - - If KIND is zero, create a TREE_LIST with the decl in TREE_PURPOSE; - return the list created. */ - -static tree -cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind, - tree list) -{ - while (1) - { - tree name, decl; - - name = cp_parser_id_expression (parser, /*template_p=*/false, - /*check_dependency_p=*/true, - /*template_p=*/NULL, - /*declarator_p=*/false, - /*optional_p=*/false); - if (name == error_mark_node) - goto skip_comma; - - decl = cp_parser_lookup_name_simple (parser, name); - if (decl == error_mark_node) - cp_parser_name_lookup_error (parser, name, decl, NULL); - else if (kind != 0) - { - tree u = build_omp_clause (kind); - OMP_CLAUSE_DECL (u) = decl; - OMP_CLAUSE_CHAIN (u) = list; - list = u; - } - else - list = tree_cons (decl, NULL_TREE, list); - - get_comma: - if (cp_lexer_next_token_is_not (parser->lexer, CPP_COMMA)) - break; - cp_lexer_consume_token (parser->lexer); - } - - if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - { - int ending; - - /* Try to resync to an unnested comma. Copied from - cp_parser_parenthesized_expression_list. */ - skip_comma: - ending = cp_parser_skip_to_closing_parenthesis (parser, - /*recovering=*/true, - /*or_comma=*/true, - /*consume_paren=*/true); - if (ending < 0) - goto get_comma; - } - - return list; -} - -/* Similarly, but expect leading and trailing parenthesis. This is a very - common case for omp clauses. */ - -static tree -cp_parser_omp_var_list (cp_parser *parser, enum omp_clause_code kind, tree list) -{ - if (cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - return cp_parser_omp_var_list_no_open (parser, kind, list); - return list; -} - -/* OpenMP 2.5: - default ( shared | none ) */ - -static tree -cp_parser_omp_clause_default (cp_parser *parser, tree list) -{ - enum omp_clause_default_kind kind = OMP_CLAUSE_DEFAULT_UNSPECIFIED; - tree c; - - if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - return list; - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - { - tree id = cp_lexer_peek_token (parser->lexer)->u.value; - const char *p = IDENTIFIER_POINTER (id); - - switch (p[0]) - { - case 'n': - if (strcmp ("none", p) != 0) - goto invalid_kind; - kind = OMP_CLAUSE_DEFAULT_NONE; - break; - - case 's': - if (strcmp ("shared", p) != 0) - goto invalid_kind; - kind = OMP_CLAUSE_DEFAULT_SHARED; - break; - - default: - goto invalid_kind; - } - - cp_lexer_consume_token (parser->lexer); - } - else - { - invalid_kind: - cp_parser_error (parser, "expected %<none%> or %<shared%>"); - } - - if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true, - /*or_comma=*/false, - /*consume_paren=*/true); - - if (kind == OMP_CLAUSE_DEFAULT_UNSPECIFIED) - return list; - - check_no_duplicate_clause (list, OMP_CLAUSE_DEFAULT, "default"); - c = build_omp_clause (OMP_CLAUSE_DEFAULT); - OMP_CLAUSE_CHAIN (c) = list; - OMP_CLAUSE_DEFAULT_KIND (c) = kind; - - return c; -} - -/* OpenMP 2.5: - if ( expression ) */ - -static tree -cp_parser_omp_clause_if (cp_parser *parser, tree list) -{ - tree t, c; - - if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - return list; - - t = cp_parser_condition (parser); - - if (t == error_mark_node - || !cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true, - /*or_comma=*/false, - /*consume_paren=*/true); - - check_no_duplicate_clause (list, OMP_CLAUSE_IF, "if"); - - c = build_omp_clause (OMP_CLAUSE_IF); - OMP_CLAUSE_IF_EXPR (c) = t; - OMP_CLAUSE_CHAIN (c) = list; - - return c; -} - -/* OpenMP 2.5: - nowait */ - -static tree -cp_parser_omp_clause_nowait (cp_parser *parser ATTRIBUTE_UNUSED, tree list) -{ - tree c; - - check_no_duplicate_clause (list, OMP_CLAUSE_NOWAIT, "nowait"); - - c = build_omp_clause (OMP_CLAUSE_NOWAIT); - OMP_CLAUSE_CHAIN (c) = list; - return c; -} - -/* OpenMP 2.5: - num_threads ( expression ) */ - -static tree -cp_parser_omp_clause_num_threads (cp_parser *parser, tree list) -{ - tree t, c; - - if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - return list; - - t = cp_parser_expression (parser, false); - - if (t == error_mark_node - || !cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true, - /*or_comma=*/false, - /*consume_paren=*/true); - - check_no_duplicate_clause (list, OMP_CLAUSE_NUM_THREADS, "num_threads"); - - c = build_omp_clause (OMP_CLAUSE_NUM_THREADS); - OMP_CLAUSE_NUM_THREADS_EXPR (c) = t; - OMP_CLAUSE_CHAIN (c) = list; - - return c; -} - -/* OpenMP 2.5: - ordered */ - -static tree -cp_parser_omp_clause_ordered (cp_parser *parser ATTRIBUTE_UNUSED, tree list) -{ - tree c; - - check_no_duplicate_clause (list, OMP_CLAUSE_ORDERED, "ordered"); - - c = build_omp_clause (OMP_CLAUSE_ORDERED); - OMP_CLAUSE_CHAIN (c) = list; - return c; -} - -/* OpenMP 2.5: - reduction ( reduction-operator : variable-list ) - - reduction-operator: - One of: + * - & ^ | && || */ - -static tree -cp_parser_omp_clause_reduction (cp_parser *parser, tree list) -{ - enum tree_code code; - tree nlist, c; - - if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - return list; - - switch (cp_lexer_peek_token (parser->lexer)->type) - { - case CPP_PLUS: - code = PLUS_EXPR; - break; - case CPP_MULT: - code = MULT_EXPR; - break; - case CPP_MINUS: - code = MINUS_EXPR; - break; - case CPP_AND: - code = BIT_AND_EXPR; - break; - case CPP_XOR: - code = BIT_XOR_EXPR; - break; - case CPP_OR: - code = BIT_IOR_EXPR; - break; - case CPP_AND_AND: - code = TRUTH_ANDIF_EXPR; - break; - case CPP_OR_OR: - code = TRUTH_ORIF_EXPR; - break; - default: - cp_parser_error (parser, "`+', `*', `-', `&', `^', `|', `&&', or `||'"); - resync_fail: - cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true, - /*or_comma=*/false, - /*consume_paren=*/true); - return list; - } - cp_lexer_consume_token (parser->lexer); - - if (!cp_parser_require (parser, CPP_COLON, "`:'")) - goto resync_fail; - - nlist = cp_parser_omp_var_list_no_open (parser, OMP_CLAUSE_REDUCTION, list); - for (c = nlist; c != list; c = OMP_CLAUSE_CHAIN (c)) - OMP_CLAUSE_REDUCTION_CODE (c) = code; - - return nlist; -} - -/* OpenMP 2.5: - schedule ( schedule-kind ) - schedule ( schedule-kind , expression ) - - schedule-kind: - static | dynamic | guided | runtime */ - -static tree -cp_parser_omp_clause_schedule (cp_parser *parser, tree list) -{ - tree c, t; - - if (!cp_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>")) - return list; - - c = build_omp_clause (OMP_CLAUSE_SCHEDULE); - - if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - { - tree id = cp_lexer_peek_token (parser->lexer)->u.value; - const char *p = IDENTIFIER_POINTER (id); - - switch (p[0]) - { - case 'd': - if (strcmp ("dynamic", p) != 0) - goto invalid_kind; - OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_DYNAMIC; - break; - - case 'g': - if (strcmp ("guided", p) != 0) - goto invalid_kind; - OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_GUIDED; - break; - - case 'r': - if (strcmp ("runtime", p) != 0) - goto invalid_kind; - OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_RUNTIME; - break; - - default: - goto invalid_kind; - } - } - else if (cp_lexer_next_token_is_keyword (parser->lexer, RID_STATIC)) - OMP_CLAUSE_SCHEDULE_KIND (c) = OMP_CLAUSE_SCHEDULE_STATIC; - else - goto invalid_kind; - cp_lexer_consume_token (parser->lexer); - - if (cp_lexer_next_token_is (parser->lexer, CPP_COMMA)) - { - cp_lexer_consume_token (parser->lexer); - - t = cp_parser_assignment_expression (parser, false); - - if (t == error_mark_node) - goto resync_fail; - else if (OMP_CLAUSE_SCHEDULE_KIND (c) == OMP_CLAUSE_SCHEDULE_RUNTIME) - error ("schedule %<runtime%> does not take " - "a %<chunk_size%> parameter"); - else - OMP_CLAUSE_SCHEDULE_CHUNK_EXPR (c) = t; - - if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - goto resync_fail; - } - else if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`,' or `)'")) - goto resync_fail; - - check_no_duplicate_clause (list, OMP_CLAUSE_SCHEDULE, "schedule"); - OMP_CLAUSE_CHAIN (c) = list; - return c; - - invalid_kind: - cp_parser_error (parser, "invalid schedule kind"); - resync_fail: - cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true, - /*or_comma=*/false, - /*consume_paren=*/true); - return list; -} - -/* Parse all OpenMP clauses. The set clauses allowed by the directive - is a bitmask in MASK. Return the list of clauses found; the result - of clause default goes in *pdefault. */ - -static tree -cp_parser_omp_all_clauses (cp_parser *parser, unsigned int mask, - const char *where, cp_token *pragma_tok) -{ - tree clauses = NULL; - - while (cp_lexer_next_token_is_not (parser->lexer, CPP_PRAGMA_EOL)) - { - pragma_omp_clause c_kind = cp_parser_omp_clause_name (parser); - const char *c_name; - tree prev = clauses; - - switch (c_kind) - { - case PRAGMA_OMP_CLAUSE_COPYIN: - clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYIN, clauses); - c_name = "copyin"; - break; - case PRAGMA_OMP_CLAUSE_COPYPRIVATE: - clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_COPYPRIVATE, - clauses); - c_name = "copyprivate"; - break; - case PRAGMA_OMP_CLAUSE_DEFAULT: - clauses = cp_parser_omp_clause_default (parser, clauses); - c_name = "default"; - break; - case PRAGMA_OMP_CLAUSE_FIRSTPRIVATE: - clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_FIRSTPRIVATE, - clauses); - c_name = "firstprivate"; - break; - case PRAGMA_OMP_CLAUSE_IF: - clauses = cp_parser_omp_clause_if (parser, clauses); - c_name = "if"; - break; - case PRAGMA_OMP_CLAUSE_LASTPRIVATE: - clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_LASTPRIVATE, - clauses); - c_name = "lastprivate"; - break; - case PRAGMA_OMP_CLAUSE_NOWAIT: - clauses = cp_parser_omp_clause_nowait (parser, clauses); - c_name = "nowait"; - break; - case PRAGMA_OMP_CLAUSE_NUM_THREADS: - clauses = cp_parser_omp_clause_num_threads (parser, clauses); - c_name = "num_threads"; - break; - case PRAGMA_OMP_CLAUSE_ORDERED: - clauses = cp_parser_omp_clause_ordered (parser, clauses); - c_name = "ordered"; - break; - case PRAGMA_OMP_CLAUSE_PRIVATE: - clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_PRIVATE, - clauses); - c_name = "private"; - break; - case PRAGMA_OMP_CLAUSE_REDUCTION: - clauses = cp_parser_omp_clause_reduction (parser, clauses); - c_name = "reduction"; - break; - case PRAGMA_OMP_CLAUSE_SCHEDULE: - clauses = cp_parser_omp_clause_schedule (parser, clauses); - c_name = "schedule"; - break; - case PRAGMA_OMP_CLAUSE_SHARED: - clauses = cp_parser_omp_var_list (parser, OMP_CLAUSE_SHARED, - clauses); - c_name = "shared"; - break; - default: - cp_parser_error (parser, "expected %<#pragma omp%> clause"); - goto saw_error; - } - - if (((mask >> c_kind) & 1) == 0) - { - /* Remove the invalid clause(s) from the list to avoid - confusing the rest of the compiler. */ - clauses = prev; - error ("%qs is not valid for %qs", c_name, where); - } - } - saw_error: - cp_parser_skip_to_pragma_eol (parser, pragma_tok); - return finish_omp_clauses (clauses); -} - -/* OpenMP 2.5: - structured-block: - statement - - In practice, we're also interested in adding the statement to an - outer node. So it is convenient if we work around the fact that - cp_parser_statement calls add_stmt. */ - -static unsigned -cp_parser_begin_omp_structured_block (cp_parser *parser) -{ - unsigned save = parser->in_statement; - - /* Only move the values to IN_OMP_BLOCK if they weren't false. - This preserves the "not within loop or switch" style error messages - for nonsense cases like - void foo() { - #pragma omp single - break; - } - */ - if (parser->in_statement) - parser->in_statement = IN_OMP_BLOCK; - - return save; -} - -static void -cp_parser_end_omp_structured_block (cp_parser *parser, unsigned save) -{ - parser->in_statement = save; -} - -static tree -cp_parser_omp_structured_block (cp_parser *parser) -{ - tree stmt = begin_omp_structured_block (); - unsigned int save = cp_parser_begin_omp_structured_block (parser); - - cp_parser_statement (parser, NULL_TREE, false); - - cp_parser_end_omp_structured_block (parser, save); - return finish_omp_structured_block (stmt); -} - -/* OpenMP 2.5: - # pragma omp atomic new-line - expression-stmt - - expression-stmt: - x binop= expr | x++ | ++x | x-- | --x - binop: - +, *, -, /, &, ^, |, <<, >> - - where x is an lvalue expression with scalar type. */ - -static void -cp_parser_omp_atomic (cp_parser *parser, cp_token *pragma_tok) -{ - tree lhs, rhs; - enum tree_code code; - - cp_parser_require_pragma_eol (parser, pragma_tok); - - lhs = cp_parser_unary_expression (parser, /*address_p=*/false, - /*cast_p=*/false); - switch (TREE_CODE (lhs)) - { - case ERROR_MARK: - goto saw_error; - - case PREINCREMENT_EXPR: - case POSTINCREMENT_EXPR: - lhs = TREE_OPERAND (lhs, 0); - code = PLUS_EXPR; - rhs = integer_one_node; - break; - - case PREDECREMENT_EXPR: - case POSTDECREMENT_EXPR: - lhs = TREE_OPERAND (lhs, 0); - code = MINUS_EXPR; - rhs = integer_one_node; - break; - - default: - switch (cp_lexer_peek_token (parser->lexer)->type) - { - case CPP_MULT_EQ: - code = MULT_EXPR; - break; - case CPP_DIV_EQ: - code = TRUNC_DIV_EXPR; - break; - case CPP_PLUS_EQ: - code = PLUS_EXPR; - break; - case CPP_MINUS_EQ: - code = MINUS_EXPR; - break; - case CPP_LSHIFT_EQ: - code = LSHIFT_EXPR; - break; - case CPP_RSHIFT_EQ: - code = RSHIFT_EXPR; - break; - case CPP_AND_EQ: - code = BIT_AND_EXPR; - break; - case CPP_OR_EQ: - code = BIT_IOR_EXPR; - break; - case CPP_XOR_EQ: - code = BIT_XOR_EXPR; - break; - default: - cp_parser_error (parser, - "invalid operator for %<#pragma omp atomic%>"); - goto saw_error; - } - cp_lexer_consume_token (parser->lexer); - - rhs = cp_parser_expression (parser, false); - if (rhs == error_mark_node) - goto saw_error; - break; - } - finish_omp_atomic (code, lhs, rhs); - cp_parser_consume_semicolon_at_end_of_statement (parser); - return; - - saw_error: - cp_parser_skip_to_end_of_block_or_statement (parser); -} - - -/* OpenMP 2.5: - # pragma omp barrier new-line */ - -static void -cp_parser_omp_barrier (cp_parser *parser, cp_token *pragma_tok) -{ - cp_parser_require_pragma_eol (parser, pragma_tok); - finish_omp_barrier (); -} - -/* OpenMP 2.5: - # pragma omp critical [(name)] new-line - structured-block */ - -static tree -cp_parser_omp_critical (cp_parser *parser, cp_token *pragma_tok) -{ - tree stmt, name = NULL; - - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - { - cp_lexer_consume_token (parser->lexer); - - name = cp_parser_identifier (parser); - - if (name == error_mark_node - || !cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true, - /*or_comma=*/false, - /*consume_paren=*/true); - if (name == error_mark_node) - name = NULL; - } - cp_parser_require_pragma_eol (parser, pragma_tok); - - stmt = cp_parser_omp_structured_block (parser); - return c_finish_omp_critical (stmt, name); -} - -/* OpenMP 2.5: - # pragma omp flush flush-vars[opt] new-line - - flush-vars: - ( variable-list ) */ - -static void -cp_parser_omp_flush (cp_parser *parser, cp_token *pragma_tok) -{ - if (cp_lexer_next_token_is (parser->lexer, CPP_OPEN_PAREN)) - (void) cp_parser_omp_var_list (parser, 0, NULL); - cp_parser_require_pragma_eol (parser, pragma_tok); - - finish_omp_flush (); -} - -/* Parse the restricted form of the for statment allowed by OpenMP. */ - -static tree -cp_parser_omp_for_loop (cp_parser *parser) -{ - tree init, cond, incr, body, decl, pre_body; - location_t loc; - - if (!cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR)) - { - cp_parser_error (parser, "for statement expected"); - return NULL; - } - loc = cp_lexer_consume_token (parser->lexer)->location; - if (!cp_parser_require (parser, CPP_OPEN_PAREN, "`('")) - return NULL; - - init = decl = NULL; - pre_body = push_stmt_list (); - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - { - cp_decl_specifier_seq type_specifiers; - - /* First, try to parse as an initialized declaration. See - cp_parser_condition, from whence the bulk of this is copied. */ - - cp_parser_parse_tentatively (parser); - cp_parser_type_specifier_seq (parser, /*is_condition=*/false, - &type_specifiers); - if (!cp_parser_error_occurred (parser)) - { - tree asm_specification, attributes; - cp_declarator *declarator; - - declarator = cp_parser_declarator (parser, - CP_PARSER_DECLARATOR_NAMED, - /*ctor_dtor_or_conv_p=*/NULL, - /*parenthesized_p=*/NULL, - /*member_p=*/false); - attributes = cp_parser_attributes_opt (parser); - asm_specification = cp_parser_asm_specification_opt (parser); - - cp_parser_require (parser, CPP_EQ, "`='"); - if (cp_parser_parse_definitely (parser)) - { - tree pushed_scope; - - decl = start_decl (declarator, &type_specifiers, - /*initialized_p=*/false, attributes, - /*prefix_attributes=*/NULL_TREE, - &pushed_scope); - - init = cp_parser_assignment_expression (parser, false); - - cp_finish_decl (decl, NULL_TREE, /*init_const_expr_p=*/false, - asm_specification, LOOKUP_ONLYCONVERTING); - - if (pushed_scope) - pop_scope (pushed_scope); - } - } - else - cp_parser_abort_tentative_parse (parser); - - /* If parsing as an initialized declaration failed, try again as - a simple expression. */ - if (decl == NULL) - init = cp_parser_expression (parser, false); - } - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); - pre_body = pop_stmt_list (pre_body); - - cond = NULL; - if (cp_lexer_next_token_is_not (parser->lexer, CPP_SEMICOLON)) - cond = cp_parser_condition (parser); - cp_parser_require (parser, CPP_SEMICOLON, "`;'"); - - incr = NULL; - if (cp_lexer_next_token_is_not (parser->lexer, CPP_CLOSE_PAREN)) - incr = cp_parser_expression (parser, false); - - if (!cp_parser_require (parser, CPP_CLOSE_PAREN, "`)'")) - cp_parser_skip_to_closing_parenthesis (parser, /*recovering=*/true, - /*or_comma=*/false, - /*consume_paren=*/true); - - /* Note that we saved the original contents of this flag when we entered - the structured block, and so we don't need to re-save it here. */ - parser->in_statement = IN_OMP_FOR; - - /* Note that the grammar doesn't call for a structured block here, - though the loop as a whole is a structured block. */ - body = push_stmt_list (); - cp_parser_statement (parser, NULL_TREE, false); - body = pop_stmt_list (body); - - return finish_omp_for (loc, decl, init, cond, incr, body, pre_body); -} - -/* OpenMP 2.5: - #pragma omp for for-clause[optseq] new-line - for-loop */ - -#define OMP_FOR_CLAUSE_MASK \ - ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \ - | (1u << PRAGMA_OMP_CLAUSE_ORDERED) \ - | (1u << PRAGMA_OMP_CLAUSE_SCHEDULE) \ - | (1u << PRAGMA_OMP_CLAUSE_NOWAIT)) - -static tree -cp_parser_omp_for (cp_parser *parser, cp_token *pragma_tok) -{ - tree clauses, sb, ret; - unsigned int save; - - clauses = cp_parser_omp_all_clauses (parser, OMP_FOR_CLAUSE_MASK, - "#pragma omp for", pragma_tok); - - sb = begin_omp_structured_block (); - save = cp_parser_begin_omp_structured_block (parser); - - ret = cp_parser_omp_for_loop (parser); - if (ret) - OMP_FOR_CLAUSES (ret) = clauses; - - cp_parser_end_omp_structured_block (parser, save); - add_stmt (finish_omp_structured_block (sb)); - - return ret; -} - -/* OpenMP 2.5: - # pragma omp master new-line - structured-block */ - -static tree -cp_parser_omp_master (cp_parser *parser, cp_token *pragma_tok) -{ - cp_parser_require_pragma_eol (parser, pragma_tok); - return c_finish_omp_master (cp_parser_omp_structured_block (parser)); -} - -/* OpenMP 2.5: - # pragma omp ordered new-line - structured-block */ - -static tree -cp_parser_omp_ordered (cp_parser *parser, cp_token *pragma_tok) -{ - cp_parser_require_pragma_eol (parser, pragma_tok); - return c_finish_omp_ordered (cp_parser_omp_structured_block (parser)); -} - -/* OpenMP 2.5: - - section-scope: - { section-sequence } - - section-sequence: - section-directive[opt] structured-block - section-sequence section-directive structured-block */ - -static tree -cp_parser_omp_sections_scope (cp_parser *parser) -{ - tree stmt, substmt; - bool error_suppress = false; - cp_token *tok; - - if (!cp_parser_require (parser, CPP_OPEN_BRACE, "`{'")) - return NULL_TREE; - - stmt = push_stmt_list (); - - if (cp_lexer_peek_token (parser->lexer)->pragma_kind != PRAGMA_OMP_SECTION) - { - unsigned save; - - substmt = begin_omp_structured_block (); - save = cp_parser_begin_omp_structured_block (parser); - - while (1) - { - cp_parser_statement (parser, NULL_TREE, false); - - tok = cp_lexer_peek_token (parser->lexer); - if (tok->pragma_kind == PRAGMA_OMP_SECTION) - break; - if (tok->type == CPP_CLOSE_BRACE) - break; - if (tok->type == CPP_EOF) - break; - } - - cp_parser_end_omp_structured_block (parser, save); - substmt = finish_omp_structured_block (substmt); - substmt = build1 (OMP_SECTION, void_type_node, substmt); - add_stmt (substmt); - } - - while (1) - { - tok = cp_lexer_peek_token (parser->lexer); - if (tok->type == CPP_CLOSE_BRACE) - break; - if (tok->type == CPP_EOF) - break; - - if (tok->pragma_kind == PRAGMA_OMP_SECTION) - { - cp_lexer_consume_token (parser->lexer); - cp_parser_require_pragma_eol (parser, tok); - error_suppress = false; - } - else if (!error_suppress) - { - cp_parser_error (parser, "expected %<#pragma omp section%> or %<}%>"); - error_suppress = true; - } - - substmt = cp_parser_omp_structured_block (parser); - substmt = build1 (OMP_SECTION, void_type_node, substmt); - add_stmt (substmt); - } - cp_parser_require (parser, CPP_CLOSE_BRACE, "`}'"); - - substmt = pop_stmt_list (stmt); - - stmt = make_node (OMP_SECTIONS); - TREE_TYPE (stmt) = void_type_node; - OMP_SECTIONS_BODY (stmt) = substmt; - - add_stmt (stmt); - return stmt; -} - -/* OpenMP 2.5: - # pragma omp sections sections-clause[optseq] newline - sections-scope */ - -#define OMP_SECTIONS_CLAUSE_MASK \ - ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_LASTPRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \ - | (1u << PRAGMA_OMP_CLAUSE_NOWAIT)) - -static tree -cp_parser_omp_sections (cp_parser *parser, cp_token *pragma_tok) -{ - tree clauses, ret; - - clauses = cp_parser_omp_all_clauses (parser, OMP_SECTIONS_CLAUSE_MASK, - "#pragma omp sections", pragma_tok); - - ret = cp_parser_omp_sections_scope (parser); - if (ret) - OMP_SECTIONS_CLAUSES (ret) = clauses; - - return ret; -} - -/* OpenMP 2.5: - # pragma parallel parallel-clause new-line - # pragma parallel for parallel-for-clause new-line - # pragma parallel sections parallel-sections-clause new-line */ - -#define OMP_PARALLEL_CLAUSE_MASK \ - ( (1u << PRAGMA_OMP_CLAUSE_IF) \ - | (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_DEFAULT) \ - | (1u << PRAGMA_OMP_CLAUSE_SHARED) \ - | (1u << PRAGMA_OMP_CLAUSE_COPYIN) \ - | (1u << PRAGMA_OMP_CLAUSE_REDUCTION) \ - | (1u << PRAGMA_OMP_CLAUSE_NUM_THREADS)) - -static tree -cp_parser_omp_parallel (cp_parser *parser, cp_token *pragma_tok) -{ - enum pragma_kind p_kind = PRAGMA_OMP_PARALLEL; - const char *p_name = "#pragma omp parallel"; - tree stmt, clauses, par_clause, ws_clause, block; - unsigned int mask = OMP_PARALLEL_CLAUSE_MASK; - unsigned int save; - - if (cp_lexer_next_token_is_keyword (parser->lexer, RID_FOR)) - { - cp_lexer_consume_token (parser->lexer); - p_kind = PRAGMA_OMP_PARALLEL_FOR; - p_name = "#pragma omp parallel for"; - mask |= OMP_FOR_CLAUSE_MASK; - mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT); - } - else if (cp_lexer_next_token_is (parser->lexer, CPP_NAME)) - { - tree id = cp_lexer_peek_token (parser->lexer)->u.value; - const char *p = IDENTIFIER_POINTER (id); - if (strcmp (p, "sections") == 0) - { - cp_lexer_consume_token (parser->lexer); - p_kind = PRAGMA_OMP_PARALLEL_SECTIONS; - p_name = "#pragma omp parallel sections"; - mask |= OMP_SECTIONS_CLAUSE_MASK; - mask &= ~(1u << PRAGMA_OMP_CLAUSE_NOWAIT); - } - } - - clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok); - block = begin_omp_parallel (); - save = cp_parser_begin_omp_structured_block (parser); - - switch (p_kind) - { - case PRAGMA_OMP_PARALLEL: - cp_parser_already_scoped_statement (parser); - par_clause = clauses; - break; - - case PRAGMA_OMP_PARALLEL_FOR: - c_split_parallel_clauses (clauses, &par_clause, &ws_clause); - stmt = cp_parser_omp_for_loop (parser); - if (stmt) - OMP_FOR_CLAUSES (stmt) = ws_clause; - break; - - case PRAGMA_OMP_PARALLEL_SECTIONS: - c_split_parallel_clauses (clauses, &par_clause, &ws_clause); - stmt = cp_parser_omp_sections_scope (parser); - if (stmt) - OMP_SECTIONS_CLAUSES (stmt) = ws_clause; - break; - - default: - gcc_unreachable (); - } - - cp_parser_end_omp_structured_block (parser, save); - stmt = finish_omp_parallel (par_clause, block); - if (p_kind != PRAGMA_OMP_PARALLEL) - OMP_PARALLEL_COMBINED (stmt) = 1; - return stmt; -} - -/* OpenMP 2.5: - # pragma omp single single-clause[optseq] new-line - structured-block */ - -#define OMP_SINGLE_CLAUSE_MASK \ - ( (1u << PRAGMA_OMP_CLAUSE_PRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_FIRSTPRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_COPYPRIVATE) \ - | (1u << PRAGMA_OMP_CLAUSE_NOWAIT)) - -static tree -cp_parser_omp_single (cp_parser *parser, cp_token *pragma_tok) -{ - tree stmt = make_node (OMP_SINGLE); - TREE_TYPE (stmt) = void_type_node; - - OMP_SINGLE_CLAUSES (stmt) - = cp_parser_omp_all_clauses (parser, OMP_SINGLE_CLAUSE_MASK, - "#pragma omp single", pragma_tok); - OMP_SINGLE_BODY (stmt) = cp_parser_omp_structured_block (parser); - - return add_stmt (stmt); -} - -/* OpenMP 2.5: - # pragma omp threadprivate (variable-list) */ - -static void -cp_parser_omp_threadprivate (cp_parser *parser, cp_token *pragma_tok) -{ - tree vars; - - vars = cp_parser_omp_var_list (parser, 0, NULL); - cp_parser_require_pragma_eol (parser, pragma_tok); - - if (!targetm.have_tls) - sorry ("threadprivate variables not supported in this target"); - - finish_omp_threadprivate (vars); -} - -/* Main entry point to OpenMP statement pragmas. */ - -static void -cp_parser_omp_construct (cp_parser *parser, cp_token *pragma_tok) -{ - tree stmt; - - switch (pragma_tok->pragma_kind) - { - case PRAGMA_OMP_ATOMIC: - cp_parser_omp_atomic (parser, pragma_tok); - return; - case PRAGMA_OMP_CRITICAL: - stmt = cp_parser_omp_critical (parser, pragma_tok); - break; - case PRAGMA_OMP_FOR: - stmt = cp_parser_omp_for (parser, pragma_tok); - break; - case PRAGMA_OMP_MASTER: - stmt = cp_parser_omp_master (parser, pragma_tok); - break; - case PRAGMA_OMP_ORDERED: - stmt = cp_parser_omp_ordered (parser, pragma_tok); - break; - case PRAGMA_OMP_PARALLEL: - stmt = cp_parser_omp_parallel (parser, pragma_tok); - break; - case PRAGMA_OMP_SECTIONS: - stmt = cp_parser_omp_sections (parser, pragma_tok); - break; - case PRAGMA_OMP_SINGLE: - stmt = cp_parser_omp_single (parser, pragma_tok); - break; - default: - gcc_unreachable (); - } - - if (stmt) - SET_EXPR_LOCATION (stmt, pragma_tok->location); -} - -/* The parser. */ - -static GTY (()) cp_parser *the_parser; - - -/* Special handling for the first token or line in the file. The first - thing in the file might be #pragma GCC pch_preprocess, which loads a - PCH file, which is a GC collection point. So we need to handle this - first pragma without benefit of an existing lexer structure. - - Always returns one token to the caller in *FIRST_TOKEN. This is - either the true first token of the file, or the first token after - the initial pragma. */ - -static void -cp_parser_initial_pragma (cp_token *first_token) -{ - tree name = NULL; - - cp_lexer_get_preprocessor_token (NULL, first_token); - /* APPLE LOCAL begin 4137741 */ - while (first_token->type == CPP_BINCL - || first_token->type == CPP_EINCL) - { - if (first_token->type == CPP_BINCL) - (*debug_hooks->start_source_file) (TREE_INT_CST_LOW (first_token->u.value), - first_token->location.file); - else - (*debug_hooks->end_source_file) (TREE_INT_CST_LOW (first_token->u.value)); - cp_lexer_get_preprocessor_token (NULL, first_token); - } - /* APPLE LOCAL end 4137741 */ - if (first_token->pragma_kind != PRAGMA_GCC_PCH_PREPROCESS) - return; - - cp_lexer_get_preprocessor_token (NULL, first_token); - if (first_token->type == CPP_STRING) - { - name = first_token->u.value; - - cp_lexer_get_preprocessor_token (NULL, first_token); - if (first_token->type != CPP_PRAGMA_EOL) - error ("junk at end of %<#pragma GCC pch_preprocess%>"); - } - else - error ("expected string literal"); - - /* Skip to the end of the pragma. */ - while (first_token->type != CPP_PRAGMA_EOL && first_token->type != CPP_EOF) - cp_lexer_get_preprocessor_token (NULL, first_token); - - /* Now actually load the PCH file. */ - if (name) - c_common_pch_pragma (parse_in, TREE_STRING_POINTER (name)); - - /* Read one more token to return to our caller. We have to do this - after reading the PCH file in, since its pointers have to be - live. */ - cp_lexer_get_preprocessor_token (NULL, first_token); -} - -/* Normal parsing of a pragma token. Here we can (and must) use the - regular lexer. */ - -static bool -cp_parser_pragma (cp_parser *parser, enum pragma_context context) -{ - cp_token *pragma_tok; - unsigned int id; - - pragma_tok = cp_lexer_consume_token (parser->lexer); - gcc_assert (pragma_tok->type == CPP_PRAGMA); - parser->lexer->in_pragma = true; - - id = pragma_tok->pragma_kind; - switch (id) - { - case PRAGMA_GCC_PCH_PREPROCESS: - error ("%<#pragma GCC pch_preprocess%> must be first"); - break; - - case PRAGMA_OMP_BARRIER: - switch (context) - { - case pragma_compound: - cp_parser_omp_barrier (parser, pragma_tok); - return false; - case pragma_stmt: - error ("%<#pragma omp barrier%> may only be " - "used in compound statements"); - break; - default: - goto bad_stmt; - } - break; - - case PRAGMA_OMP_FLUSH: - switch (context) - { - case pragma_compound: - cp_parser_omp_flush (parser, pragma_tok); - return false; - case pragma_stmt: - error ("%<#pragma omp flush%> may only be " - "used in compound statements"); - break; - default: - goto bad_stmt; - } - break; - - case PRAGMA_OMP_THREADPRIVATE: - cp_parser_omp_threadprivate (parser, pragma_tok); - return false; - - case PRAGMA_OMP_ATOMIC: - case PRAGMA_OMP_CRITICAL: - case PRAGMA_OMP_FOR: - case PRAGMA_OMP_MASTER: - case PRAGMA_OMP_ORDERED: - case PRAGMA_OMP_PARALLEL: - case PRAGMA_OMP_SECTIONS: - case PRAGMA_OMP_SINGLE: - if (context == pragma_external) - goto bad_stmt; - cp_parser_omp_construct (parser, pragma_tok); - return true; - - case PRAGMA_OMP_SECTION: - error ("%<#pragma omp section%> may only be used in " - "%<#pragma omp sections%> construct"); - break; - - default: - gcc_assert (id >= PRAGMA_FIRST_EXTERNAL); - c_invoke_pragma_handler (id); - break; - - bad_stmt: - cp_parser_error (parser, "expected declaration specifiers"); - break; - } - - cp_parser_skip_to_pragma_eol (parser, pragma_tok); - return false; -} - -/* The interface the pragma parsers have to the lexer. */ - -enum cpp_ttype -pragma_lex (tree *value) -{ - cp_token *tok; - enum cpp_ttype ret; - - tok = cp_lexer_peek_token (the_parser->lexer); - - ret = tok->type; - *value = tok->u.value; - - if (ret == CPP_PRAGMA_EOL || ret == CPP_EOF) - ret = CPP_EOF; - else if (ret == CPP_STRING) - *value = cp_parser_string_literal (the_parser, false, false); - else - { - cp_lexer_consume_token (the_parser->lexer); - if (ret == CPP_KEYWORD) - ret = CPP_NAME; - } - - return ret; -} - - -/* External interface. */ - -/* Parse one entire translation unit. */ - -void -c_parse_file (void) -{ - bool error_occurred; - static bool already_called = false; - - if (already_called) - { - sorry ("inter-module optimizations not implemented for C++"); - return; - } - already_called = true; - - the_parser = cp_parser_new (); - push_deferring_access_checks (flag_access_control - ? dk_no_deferred : dk_no_check); - error_occurred = cp_parser_translation_unit (the_parser); - the_parser = NULL; - /* APPLE LOCAL begin radar 4874613 */ - /* Bad parse errors. Just forget about it. */ - if (! global_bindings_p () || current_class_type || decl_namespace_list) - return; - if (pch_file) - c_common_write_pch (); - /* APPLE LOCAL end radar 4874613 */ -} - -/* This variable must be provided by every front end. */ - -int yydebug; - -#include "gt-cp-parser.h" |