/* Common initialization before parsing options. */
unsigned int
c_common_init_options (unsigned int argc, const char **argv)
{
static const unsigned int lang_flags[] = {CL_C, CL_ObjC, CL_CXX, CL_ObjCXX};
unsigned int i, result;
/* This is conditionalized only because that is the way the front
ends used to do it. Maybe this should be unconditional? */
if (c_dialect_cxx ())
{
/* By default wrap lines at 80 characters. Is getenv
("COLUMNS") preferable? */
diagnostic_line_cutoff (global_dc) = 80;
/* By default, emit location information once for every
diagnostic message. */
diagnostic_prefixing_rule (global_dc) = DIAGNOSTICS_SHOW_PREFIX_ONCE;
}
parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
ident_hash, &line_table);
cpp_opts = cpp_get_options (parse_in);
cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
cpp_opts->objc = c_dialect_objc ();
/* Reset to avoid warnings on internal definitions. We set it just
before passing on command-line options to cpplib. */
cpp_opts->warn_dollars = 0;
flag_exceptions = c_dialect_cxx ();
warn_pointer_arith = c_dialect_cxx ();
warn_write_strings = c_dialect_cxx();
deferred_opts = XNEWVEC (struct deferred_opt, argc);
result = lang_flags[c_language];
if (c_language == clk_c)
{
/* If preprocessing assembly language, accept any of the C-family
front end options since the driver may pass them through. */
for (i = 1; i < argc; i++)
if (! strcmp (argv[i], "-lang-asm"))
{
result |= CL_C | CL_ObjC | CL_CXX | CL_ObjCXX;
break;
}
#ifdef CL_Fortran
for (i = 1; i < argc; i++)
if (! strcmp (argv[i], "-lang-fortran"))
{
result |= CL_Fortran;
break;
}
#endif
}
return result;
}
/* Common initialization before calling option handlers. */
void
c_common_init_options (unsigned int decoded_options_count,
struct cl_decoded_option *decoded_options)
{
unsigned int i;
struct cpp_callbacks *cb;
parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
ident_hash, line_table);
cb = cpp_get_callbacks (parse_in);
cb->error = c_cpp_error;
cpp_opts = cpp_get_options (parse_in);
cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
cpp_opts->objc = c_dialect_objc ();
/* Reset to avoid warnings on internal definitions. We set it just
before passing on command-line options to cpplib. */
cpp_opts->warn_dollars = 0;
deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count);
if (c_language == clk_c)
{
/* If preprocessing assembly language, accept any of the C-family
front end options since the driver may pass them through. */
for (i = 1; i < decoded_options_count; i++)
if (decoded_options[i].opt_index == OPT_lang_asm)
{
accept_all_c_family_options = true;
break;
}
}
}
/* Common initialization before calling option handlers. */
void
c_common_init_options (unsigned int decoded_options_count,
struct cl_decoded_option *decoded_options)
{
unsigned int i;
struct cpp_callbacks *cb;
g_string_concat_db
= new (ggc_alloc <string_concat_db> ()) string_concat_db ();
parse_in = cpp_create_reader (c_dialect_cxx () ? CLK_GNUCXX: CLK_GNUC89,
ident_hash, line_table);
cb = cpp_get_callbacks (parse_in);
cb->diagnostic = c_cpp_diagnostic;
cpp_opts = cpp_get_options (parse_in);
cpp_opts->dollars_in_ident = DOLLARS_IN_IDENTIFIERS;
cpp_opts->objc = c_dialect_objc ();
/* Reset to avoid warnings on internal definitions. We set it just
before passing on command-line options to cpplib. */
cpp_opts->warn_dollars = 0;
deferred_opts = XNEWVEC (struct deferred_opt, decoded_options_count);
if (c_language == clk_c)
{
/* The default for C is gnu17. */
set_std_c17 (false /* ISO */);
/* If preprocessing assembly language, accept any of the C-family
front end options since the driver may pass them through. */
for (i = 1; i < decoded_options_count; i++)
if (decoded_options[i].opt_index == OPT_lang_asm)
{
accept_all_c_family_options = true;
break;
}
}
/* Set C++ standard to C++14 if not specified on the command line. */
if (c_dialect_cxx ())
set_std_cxx14 (/*ISO*/false);
global_dc->colorize_source_p = true;
}
static tree
/* APPLE LOCAL radar 2848255 */
do_begin_catch (tree type)
{
tree fn;
/* APPLE LOCAL begin radar 2848255 */
if (c_dialect_objc () && objc2_valid_objc_catch_type (type))
fn = get_identifier ("objc_begin_catch");
else
fn = get_identifier ("__cxa_begin_catch");
/* APPLE LOCAL end radar 2848255 */
if (!get_global_value_if_present (fn, &fn))
{
/* Declare void* __cxa_begin_catch (void *). */
tree tmp = tree_cons (NULL_TREE, ptr_type_node, void_list_node);
fn = push_library_fn (fn, build_function_type (ptr_type_node, tmp));
}
return build_function_call (fn, tree_cons (NULL_TREE, build_exc_ptr (),
NULL_TREE));
}
static tree
do_end_catch (tree type)
{
tree fn, cleanup;
/* APPLE LOCAL begin radar 2848255 */
if (c_dialect_objc () && objc2_valid_objc_catch_type (type))
fn = get_identifier ("objc_end_catch");
else
fn = get_identifier ("__cxa_end_catch");
/* APPLE LOCAL end radar 2848255 */
if (!get_global_value_if_present (fn, &fn))
{
/* Declare void __cxa_end_catch (). */
fn = push_void_library_fn (fn, void_list_node);
/* This can throw if the destructor for the exception throws. */
TREE_NOTHROW (fn) = 0;
}
cleanup = build_function_call (fn, NULL_TREE);
TREE_NOTHROW (cleanup) = dtor_nothrow (type);
return cleanup;
}
static enum cpp_ttype
lex_string (const cpp_token *tok, tree *valp, bool objc_string)
{
tree value;
bool wide = false;
size_t concats = 0;
struct obstack str_ob;
cpp_string istr;
/* Try to avoid the overhead of creating and destroying an obstack
for the common case of just one string. */
cpp_string str = tok->val.str;
cpp_string *strs = &str;
if (tok->type == CPP_WSTRING)
wide = true;
retry:
tok = cpp_get_token (parse_in);
switch (tok->type)
{
case CPP_PADDING:
goto retry;
case CPP_ATSIGN:
if (c_dialect_objc ())
{
objc_string = true;
goto retry;
}
/* FALLTHROUGH */
default:
break;
case CPP_WSTRING:
wide = true;
/* FALLTHROUGH */
case CPP_STRING:
if (!concats)
{
gcc_obstack_init (&str_ob);
obstack_grow (&str_ob, &str, sizeof (cpp_string));
}
concats++;
obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
goto retry;
}
/* We have read one more token than we want. */
_cpp_backup_tokens (parse_in, 1);
if (concats)
strs = XOBFINISH (&str_ob, cpp_string *);
if (concats && !objc_string && !in_system_header)
warning (OPT_Wtraditional,
"traditional C rejects string constant concatenation");
if ((c_lex_string_translate
? cpp_interpret_string : cpp_interpret_string_notranslate)
(parse_in, strs, concats + 1, &istr, wide))
{
value = build_string (istr.len, (char *) istr.text);
free ((void *) istr.text);
if (c_lex_string_translate == -1)
{
int xlated = cpp_interpret_string_notranslate (parse_in, strs,
concats + 1,
&istr, wide);
/* Assume that, if we managed to translate the string above,
then the untranslated parsing will always succeed. */
gcc_assert (xlated);
if (TREE_STRING_LENGTH (value) != (int) istr.len
|| 0 != strncmp (TREE_STRING_POINTER (value), (char *) istr.text,
istr.len))
{
/* Arrange for us to return the untranslated string in
*valp, but to set up the C type of the translated
one. */
*valp = build_string (istr.len, (char *) istr.text);
valp = &TREE_CHAIN (*valp);
}
free ((void *) istr.text);
}
}
else
{
/* Callers cannot generally handle error_mark_node in this context,
so return the empty string instead. cpp_interpret_string has
issued an error. */
if (wide)
value = build_string (TYPE_PRECISION (wchar_type_node)
/ TYPE_PRECISION (char_type_node),
"\0\0\0"); /* widest supported wchar_t
is 32 bits */
else
value = build_string (1, "");
}
TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node;
*valp = fix_string_type (value);
if (concats)
obstack_free (&str_ob, 0);
return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING;
}
enum cpp_ttype
c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags)
{
static bool no_more_pch;
const cpp_token *tok;
enum cpp_ttype type;
timevar_push (TV_CPP);
retry:
tok = cpp_get_token (parse_in);
type = tok->type;
retry_after_at:
#ifdef USE_MAPPED_LOCATION
*loc = tok->src_loc;
#else
*loc = input_location;
#endif
switch (type)
{
case CPP_PADDING:
goto retry;
case CPP_NAME:
*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
break;
case CPP_NUMBER:
{
unsigned int flags = cpp_classify_number (parse_in, tok);
switch (flags & CPP_N_CATEGORY)
{
case CPP_N_INVALID:
/* cpplib has issued an error. */
*value = error_mark_node;
errorcount++;
break;
case CPP_N_INTEGER:
*value = interpret_integer (tok, flags);
break;
case CPP_N_FLOATING:
*value = interpret_float (tok, flags);
break;
default:
gcc_unreachable ();
}
}
break;
case CPP_ATSIGN:
/* An @ may give the next token special significance in Objective-C. */
if (c_dialect_objc ())
{
location_t atloc = input_location;
retry_at:
tok = cpp_get_token (parse_in);
type = tok->type;
switch (type)
{
case CPP_PADDING:
goto retry_at;
case CPP_STRING:
case CPP_WSTRING:
type = lex_string (tok, value, true);
break;
case CPP_NAME:
*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
if (objc_is_reserved_word (*value))
{
type = CPP_AT_NAME;
break;
}
/* FALLTHROUGH */
default:
/* ... or not. */
error ("%Hstray %<@%> in program", &atloc);
goto retry_after_at;
}
break;
}
/* FALLTHROUGH */
case CPP_HASH:
case CPP_PASTE:
{
unsigned char name[4];
*cpp_spell_token (parse_in, tok, name, true) = 0;
error ("stray %qs in program", name);
}
goto retry;
case CPP_OTHER:
{
cppchar_t c = tok->val.str.text[0];
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 retry;
case CPP_CHAR:
case CPP_WCHAR:
*value = lex_charconst (tok);
break;
case CPP_STRING:
case CPP_WSTRING:
if (!c_lex_return_raw_strings)
{
type = lex_string (tok, value, false);
break;
}
/* FALLTHROUGH */
case CPP_PRAGMA:
*value = build_string (tok->val.str.len, (char *) tok->val.str.text);
break;
/* These tokens should not be visible outside cpplib. */
case CPP_HEADER_NAME:
case CPP_COMMENT:
case CPP_MACRO_ARG:
gcc_unreachable ();
default:
*value = NULL_TREE;
break;
}
if (cpp_flags)
*cpp_flags = tok->flags;
if (!no_more_pch)
{
no_more_pch = true;
c_common_no_more_pch ();
}
timevar_pop (TV_CPP);
return type;
}
/* Hook that registers front end and target-specific built-ins. */
void
c_cpp_builtins (cpp_reader *pfile)
{
/* -undef turns off target-specific built-ins. */
if (flag_undef)
return;
define__GNUC__ ();
/* For stddef.h. They require macros defined in c-common.c. */
c_stddef_cpp_builtins ();
if (c_dialect_cxx ())
{
if (flag_weak && SUPPORTS_ONE_ONLY)
cpp_define (pfile, "__GXX_WEAK__=1");
else
cpp_define (pfile, "__GXX_WEAK__=0");
if (warn_deprecated)
cpp_define (pfile, "__DEPRECATED");
}
/* Note that we define this for C as well, so that we know if
__attribute__((cleanup)) will interface with EH. */
if (flag_exceptions)
cpp_define (pfile, "__EXCEPTIONS");
/* Represents the C++ ABI version, always defined so it can be used while
preprocessing C and assembler. */
if (flag_abi_version == 0)
/* Use a very large value so that:
#if __GXX_ABI_VERSION >= <value for version X>
will work whether the user explicitly says "-fabi-version=x" or
"-fabi-version=0". Do not use INT_MAX because that will be
different from system to system. */
builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
else if (flag_abi_version == 1)
/* Due to a historical accident, this version had the value
"102". */
builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
else
/* Newer versions have values 1002, 1003, .... */
builtin_define_with_int_value ("__GXX_ABI_VERSION",
1000 + flag_abi_version);
/* libgcc needs to know this. */
if (USING_SJLJ_EXCEPTIONS)
cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
/* limits.h needs to know these. */
builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
/* stdint.h (eventually) and the testsuite need to know these. */
builtin_define_stdint_macros ();
/* float.h needs to know these. */
builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
TARGET_FLT_EVAL_METHOD);
/* And decfloat.h needs this. */
builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
TARGET_DEC_EVAL_METHOD);
builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
/* Cast the double precision constants when single precision constants are
specified. The correct result is computed by the compiler when using
macros that include a cast. This has the side-effect of making the value
unusable in const expressions. */
if (flag_single_precision_constant)
builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
else
builtin_define_float_constants ("DBL", "", "%s", double_type_node);
builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
/* For decfloat.h. */
builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
/* For use in assembly language. */
builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
/* Misc. */
builtin_define_with_value ("__VERSION__", version_string, 1);
cpp_define (pfile, "__GNUC_GNU_INLINE__");
/* Definitions for LP64 model. */
if (TYPE_PRECISION (long_integer_type_node) == 64
&& POINTER_SIZE == 64
&& TYPE_PRECISION (integer_type_node) == 32)
{
cpp_define (pfile, "_LP64");
cpp_define (pfile, "__LP64__");
}
/* Other target-independent built-ins determined by command-line
options. */
if (optimize_size)
cpp_define (pfile, "__OPTIMIZE_SIZE__");
if (optimize)
cpp_define (pfile, "__OPTIMIZE__");
if (fast_math_flags_set_p ())
cpp_define (pfile, "__FAST_MATH__");
if (flag_really_no_inline)
cpp_define (pfile, "__NO_INLINE__");
if (flag_signaling_nans)
cpp_define (pfile, "__SUPPORT_SNAN__");
if (flag_finite_math_only)
cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
else
cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
if (flag_pic)
{
builtin_define_with_int_value ("__pic__", flag_pic);
builtin_define_with_int_value ("__PIC__", flag_pic);
}
if (flag_iso)
cpp_define (pfile, "__STRICT_ANSI__");
if (!flag_signed_char)
cpp_define (pfile, "__CHAR_UNSIGNED__");
if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
cpp_define (pfile, "__WCHAR_UNSIGNED__");
/* Make the choice of ObjC runtime visible to source code. */
if (c_dialect_objc () && flag_next_runtime)
cpp_define (pfile, "__NEXT_RUNTIME__");
/* Show the availability of some target pragmas. */
if (flag_mudflap || targetm.handle_pragma_redefine_extname)
cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
if (targetm.handle_pragma_extern_prefix)
cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
/* Make the choice of the stack protector runtime visible to source code.
The macro names and values here were chosen for compatibility with an
earlier implementation, i.e. ProPolice. */
if (flag_stack_protect == 2)
cpp_define (pfile, "__SSP_ALL__=2");
else if (flag_stack_protect == 1)
cpp_define (pfile, "__SSP__=1");
if (flag_openmp)
cpp_define (pfile, "_OPENMP=200505");
/* A straightforward target hook doesn't work, because of problems
linking that hook's body when part of non-C front ends. */
# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
# define builtin_define(TXT) cpp_define (pfile, TXT)
# define builtin_assert(TXT) cpp_assert (pfile, TXT)
TARGET_CPU_CPP_BUILTINS ();
TARGET_OS_CPP_BUILTINS ();
TARGET_OBJFMT_CPP_BUILTINS ();
/* Support the __declspec keyword by turning them into attributes.
Note that the current way we do this may result in a collision
with predefined attributes later on. This can be solved by using
one attribute, say __declspec__, and passing args to it. The
problem with that approach is that args are not accumulated: each
new appearance would clobber any existing args. */
if (TARGET_DECLSPEC)
builtin_define ("__declspec(x)=__attribute__((x))");
}
enum cpp_ttype
/* APPLE LOCAL CW asm blocks C++ comments 6338079 */
c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags, int defer)
{
static bool no_more_pch;
const cpp_token *tok;
enum cpp_ttype type;
unsigned char add_flags = 0;
/* APPLE LOCAL CW asm blocks C++ */
const cpp_token *lasttok;
/* APPLE LOCAL begin CW asm blocks */
/* Make a local copy of the flag for efficiency, since the compiler can't
figure that it won't change during a compilation. */
int flag_iasm_blocks_local = flag_iasm_blocks;
if (flag_iasm_blocks_local)
++c_lex_depth;
/* APPLE LOCAL end CW asm blocks */
timevar_push (TV_CPP);
retry:
/* APPLE LOCAL begin CW asm blocks */
/* If there's a token we saved while returning the special BOL
token, return it now. */
if (iasm_saved_token)
{
tok = iasm_saved_token;
type = tok->type;
iasm_saved_token = NULL;
goto bypass;
}
/* APPLE LOCAL end CW asm blocks */
tok = cpp_get_token (parse_in);
type = tok->type;
/* APPLE LOCAL begin CW asm blocks */
/* This test should be as efficient as possible, because it affects
all lexing with or without CW asm enabled. */
if (flag_iasm_blocks_local && iasm_state != iasm_none && c_lex_depth == 1
&& type != CPP_PADDING)
{
/* "}" switches us out of our special mode. */
if (tok->type == CPP_CLOSE_BRACE && iasm_state >= iasm_decls)
iasm_state = iasm_none;
/* This is tricky. We're only ready to start parsing assembly
instructions if we're in the asm block, we're not in the
middle of parsing a C decl, and the next token is plausibly
the beginning of an asm line. This works because if we have
a "typedef int nop", a nop at the beginning of a line should
be taken as an instruction rather than a declaration of type
nop. (Doesn't have to go this way, but it's how CW works.)
We're not quite as good as CW yet, because CW knows about the
complete list of valid opcodes, and will try to take anything
as a decl that is not in the opcode list. */
if (iasm_state == iasm_decls
&& !iasm_in_decl)
{
if (tok->type == CPP_ATSIGN
|| tok->type == CPP_DOT
|| (tok->type == CPP_SEMICOLON)
|| (tok->type == CPP_NAME
&& (*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node)))
&& !iasm_typename_or_reserved (*value)))
{
iasm_state = iasm_asm;
inside_iasm_block = true;
}
else
{
iasm_in_decl = true;
}
}
}
bypass:
/* APPLE LOCAL end CW asm blocks */
retry_after_at:
#ifdef USE_MAPPED_LOCATION
*loc = tok->src_loc;
#else
*loc = input_location;
#endif
switch (type)
{
case CPP_PADDING:
goto retry;
case CPP_NAME:
*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
/* APPLE LOCAL begin CW asm blocks */
if (iasm_state >= iasm_decls
&& flag_ms_asms
&& strcasecmp (IDENTIFIER_POINTER (HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node))),
"offset") == 0)
{
type = CPP_AND;
*value = NULL_TREE;
break;
}
/* APPLE LOCAL end CW asm blocks */
break;
case CPP_NUMBER:
{
/* APPLE LOCAL CW asm blocks C++ comments 6338079 */
unsigned int flags = cpp_classify_number (parse_in, tok, defer);
switch (flags & CPP_N_CATEGORY)
{
case CPP_N_INVALID:
/* APPLE LOCAL begin CW asm blocks C++ comments 6338079 */
if (flags & CPP_N_DEFER)
{
add_flags = ERROR_DEFERRED;
*value = error_mark_node;
break;
}
/* APPLE LOCAL end CW asm blocks C++ comments 6338079 */
/* cpplib has issued an error. */
*value = error_mark_node;
errorcount++;
break;
case CPP_N_INTEGER:
/* C++ uses '0' to mark virtual functions as pure.
Set PURE_ZERO to pass this information to the C++ parser. */
if (tok->val.str.len == 1 && *tok->val.str.text == '0')
add_flags = PURE_ZERO;
*value = interpret_integer (tok, flags);
break;
case CPP_N_FLOATING:
*value = interpret_float (tok, flags);
break;
default:
gcc_unreachable ();
}
}
break;
case CPP_ATSIGN:
/* APPLE LOCAL begin CW asm blocks */
if (iasm_state >= iasm_decls)
{
/* Return the @-sign verbatim. */
*value = NULL_TREE;
break;
}
lasttok = tok;
/* APPLE LOCAL end CW asm blocks */
/* An @ may give the next token special significance in Objective-C. */
if (c_dialect_objc ())
{
location_t atloc = input_location;
/* APPLE LOCAL CW asm blocks */
++parse_in->keep_tokens;
retry_at:
tok = cpp_get_token (parse_in);
type = tok->type;
switch (type)
{
case CPP_PADDING:
goto retry_at;
case CPP_STRING:
case CPP_WSTRING:
type = lex_string (tok, value, true);
break;
case CPP_NAME:
*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node));
if (objc_is_reserved_word (*value))
{
type = CPP_AT_NAME;
break;
}
/* FALLTHROUGH */
default:
/* APPLE LOCAL begin CW asm blocks C++ */
if (flag_iasm_blocks_local)
{
/* This is necessary for C++, as we don't have the tight
integration between the lexer and the parser... */
_cpp_backup_tokens (parse_in, 1);
/* Return the @-sign verbatim. */
*value = NULL;
tok = lasttok;
type = tok->type;
break;
}
/* APPLE LOCAL end CW asm blocks C++ */
/* ... or not. */
error ("%Hstray %<@%> in program", &atloc);
goto retry_after_at;
}
/* APPLE LOCAL CW asm blocks */
--parse_in->keep_tokens;
break;
}
/* APPLE LOCAL begin CW asm blocks C++ */
if (flag_iasm_blocks_local)
{
/* This is necessary for C++, as we don't have the tight
integration between the lexer and the parser... */
/* Return the @-sign verbatim. */
*value = NULL;
break;
}
/* APPLE LOCAL end CW asm blocks C++ */
/* FALLTHROUGH */
case CPP_HASH:
case CPP_PASTE:
/* APPLE LOCAL begin CW asm blocks C++ comments 4248139 */
/* Because we don't recognize inline asm commments during
lexing, we have to pass this back to the parser to error out
with or eat as a comment as appropriate. */
if (flag_iasm_blocks_local)
{
*value = NULL;
break;
}
/* APPLE LOCAL end CW asm blocks C++ comments 4248139 */
{
unsigned char name[4];
*cpp_spell_token (parse_in, tok, name, true) = 0;
error ("stray %qs in program", name);
}
goto retry;
case CPP_OTHER:
{
cppchar_t c = tok->val.str.text[0];
/* APPLE LOCAL begin CW asm blocks C++ comments 4248139 */
/* Because we don't recognize inline asm commments during
lexing, we have to pass this back to the parser to error
out with or eat as a comment as appropriate. */
if (defer && flag_iasm_blocks_local)
{
*value = build_int_cst_wide (char_type_node, c, 0);
break;
}
/* APPLE LOCAL end CW asm blocks C++ comments 4248139 */
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 retry;
case CPP_CHAR:
case CPP_WCHAR:
*value = lex_charconst (tok);
break;
case CPP_STRING:
case CPP_WSTRING:
if (!c_lex_return_raw_strings)
{
type = lex_string (tok, value, false);
break;
}
*value = build_string (tok->val.str.len, (char *) tok->val.str.text);
break;
case CPP_PRAGMA:
*value = build_int_cst (NULL, tok->val.pragma);
break;
/* APPLE LOCAL begin CW asm blocks */
case CPP_MULT:
if (inside_iasm_block)
{
/* Check and replace use of '*' with '.' if '*' is followed by '-'
or '+'. This is to allow "b *+8" which is disallwed by darwin's
assembler but nevertheless is needed to be compatible with CW tools. */
lasttok = tok;
++parse_in->keep_tokens;
do
tok = cpp_get_token (parse_in);
while (tok->type == CPP_PADDING);
_cpp_backup_tokens (parse_in, 1);
--parse_in->keep_tokens;
if (tok->type == CPP_PLUS || tok->type == CPP_MINUS)
type = CPP_DOT;
tok = lasttok;
}
*value = NULL_TREE;
break;
/* APPLE LOCAL end CW asm blocks */
/* APPLE LOCAL begin 4137741 */
/* For CPP_BINCL and CPP_EINCL tokens, we shall need to propagate
line number information; the location field shall already include
the desired file name. */
case CPP_BINCL:
case CPP_EINCL:
*value = build_int_cst (integer_type_node, (HOST_WIDE_INT) tok->src_loc);
break;
/* APPLE LOCAL end 4137741 */
/* These tokens should not be visible outside cpplib. */
case CPP_HEADER_NAME:
case CPP_COMMENT:
case CPP_MACRO_ARG:
gcc_unreachable ();
default:
*value = NULL_TREE;
break;
}
if (cpp_flags)
*cpp_flags = tok->flags | add_flags;
/* APPLE LOCAL begin CW asm blocks */
if (flag_iasm_blocks_local)
--c_lex_depth;
/* APPLE LOCAL end CW asm blocks */
/* APPLE LOCAL begin 4137741 */
if (!no_more_pch
&& type != CPP_BINCL
&& type != CPP_EINCL)
/* APPLE LOCAL end 4137741 */
{
no_more_pch = true;
c_common_no_more_pch ();
}
timevar_pop (TV_CPP);
return type;
}
/* Hook that registers front end and target-specific built-ins. */
void
c_cpp_builtins (cpp_reader *pfile)
{
/* -undef turns off target-specific built-ins. */
if (flag_undef)
return;
define_language_independent_builtin_macros (pfile);
if (c_dialect_cxx ())
{
int major;
parse_basever (&major, NULL, NULL);
cpp_define_formatted (pfile, "__GNUG__=%d", major);
}
/* For stddef.h. They require macros defined in c-common.c. */
c_stddef_cpp_builtins ();
/* Set include test macros for all C/C++ (not for just C++11 etc.)
the builtins __has_include__ and __has_include_next__ are defined
in libcpp. */
cpp_define (pfile, "__has_include(STR)=__has_include__(STR)");
cpp_define (pfile, "__has_include_next(STR)=__has_include_next__(STR)");
if (c_dialect_cxx ())
{
if (flag_weak && SUPPORTS_ONE_ONLY)
cpp_define (pfile, "__GXX_WEAK__=1");
else
cpp_define (pfile, "__GXX_WEAK__=0");
if (warn_deprecated)
cpp_define (pfile, "__DEPRECATED");
if (flag_rtti)
cpp_define (pfile, "__GXX_RTTI");
if (cxx_dialect >= cxx11)
cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
/* Binary literals have been allowed in g++ before C++11
and were standardized for C++14. */
if (!pedantic || cxx_dialect > cxx11)
cpp_define (pfile, "__cpp_binary_literals=201304");
if (cxx_dialect >= cxx11)
{
/* Set feature test macros for C++11 */
cpp_define (pfile, "__cpp_unicode_characters=200704");
cpp_define (pfile, "__cpp_raw_strings=200710");
cpp_define (pfile, "__cpp_unicode_literals=200710");
cpp_define (pfile, "__cpp_user_defined_literals=200809");
cpp_define (pfile, "__cpp_lambdas=200907");
cpp_define (pfile, "__cpp_constexpr=200704");
cpp_define (pfile, "__cpp_static_assert=200410");
cpp_define (pfile, "__cpp_decltype=200707");
cpp_define (pfile, "__cpp_attributes=200809");
cpp_define (pfile, "__cpp_rvalue_reference=200610");
cpp_define (pfile, "__cpp_variadic_templates=200704");
cpp_define (pfile, "__cpp_alias_templates=200704");
}
if (cxx_dialect > cxx11)
{
/* Set feature test macros for C++14 */
cpp_define (pfile, "__cpp_return_type_deduction=201304");
cpp_define (pfile, "__cpp_init_captures=201304");
cpp_define (pfile, "__cpp_generic_lambdas=201304");
//cpp_undef (pfile, "__cpp_constexpr");
//cpp_define (pfile, "__cpp_constexpr=201304");
cpp_define (pfile, "__cpp_decltype_auto=201304");
//cpp_define (pfile, "__cpp_aggregate_nsdmi=201304");
//cpp_define (pfile, "__cpp_variable_templates=201304");
cpp_define (pfile, "__cpp_digit_separators=201309");
cpp_define (pfile, "__cpp_attribute_deprecated=201309");
//cpp_define (pfile, "__cpp_sized_deallocation=201309");
/* We'll have to see where runtime arrays wind up.
Let's put it in C++14 for now. */
cpp_define (pfile, "__cpp_runtime_arrays=201304");
}
}
/* Note that we define this for C as well, so that we know if
__attribute__((cleanup)) will interface with EH. */
if (flag_exceptions)
cpp_define (pfile, "__EXCEPTIONS");
/* Represents the C++ ABI version, always defined so it can be used while
preprocessing C and assembler. */
if (flag_abi_version == 0)
/* Use a very large value so that:
#if __GXX_ABI_VERSION >= <value for version X>
will work whether the user explicitly says "-fabi-version=x" or
"-fabi-version=0". Do not use INT_MAX because that will be
different from system to system. */
builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
else if (flag_abi_version == 1)
/* Due to a historical accident, this version had the value
"102". */
builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
else
/* Newer versions have values 1002, 1003, .... */
builtin_define_with_int_value ("__GXX_ABI_VERSION",
1000 + flag_abi_version);
/* libgcc needs to know this. */
if (targetm_common.except_unwind_info (&global_options) == UI_SJLJ)
cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
/* limits.h and stdint.h need to know these. */
builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node);
builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node);
builtin_define_type_max ("__INT_MAX__", integer_type_node);
builtin_define_type_max ("__LONG_MAX__", long_integer_type_node);
builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node);
builtin_define_type_minmax ("__WCHAR_MIN__", "__WCHAR_MAX__",
underlying_wchar_type_node);
builtin_define_type_minmax ("__WINT_MIN__", "__WINT_MAX__", wint_type_node);
builtin_define_type_max ("__PTRDIFF_MAX__", ptrdiff_type_node);
builtin_define_type_max ("__SIZE_MAX__", size_type_node);
/* stdint.h and the testsuite need to know these. */
builtin_define_stdint_macros ();
/* Provide information for library headers to determine whether to
define macros such as __STDC_IEC_559__ and
__STDC_IEC_559_COMPLEX__. */
builtin_define_with_int_value ("__GCC_IEC_559", cpp_iec_559_value ());
builtin_define_with_int_value ("__GCC_IEC_559_COMPLEX",
cpp_iec_559_complex_value ());
/* float.h needs to know this. */
builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
TARGET_FLT_EVAL_METHOD);
/* And decfloat.h needs this. */
builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
TARGET_DEC_EVAL_METHOD);
builtin_define_float_constants ("FLT", "F", "%s", "F", float_type_node);
/* Cast the double precision constants. This is needed when single
precision constants are specified or when pragma FLOAT_CONST_DECIMAL64
is used. The correct result is computed by the compiler when using
macros that include a cast. We use a different cast for C++ to avoid
problems with -Wold-style-cast. */
builtin_define_float_constants ("DBL", "L",
(c_dialect_cxx ()
? "double(%s)"
: "((double)%s)"),
"", double_type_node);
builtin_define_float_constants ("LDBL", "L", "%s", "L",
long_double_type_node);
/* For decfloat.h. */
builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
/* For fixed-point fibt, ibit, max, min, and epsilon. */
if (targetm.fixed_point_supported_p ())
{
builtin_define_fixed_point_constants ("SFRACT", "HR",
short_fract_type_node);
builtin_define_fixed_point_constants ("USFRACT", "UHR",
unsigned_short_fract_type_node);
builtin_define_fixed_point_constants ("FRACT", "R",
fract_type_node);
builtin_define_fixed_point_constants ("UFRACT", "UR",
unsigned_fract_type_node);
builtin_define_fixed_point_constants ("LFRACT", "LR",
long_fract_type_node);
builtin_define_fixed_point_constants ("ULFRACT", "ULR",
unsigned_long_fract_type_node);
builtin_define_fixed_point_constants ("LLFRACT", "LLR",
long_long_fract_type_node);
builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
unsigned_long_long_fract_type_node);
builtin_define_fixed_point_constants ("SACCUM", "HK",
short_accum_type_node);
builtin_define_fixed_point_constants ("USACCUM", "UHK",
unsigned_short_accum_type_node);
builtin_define_fixed_point_constants ("ACCUM", "K",
accum_type_node);
builtin_define_fixed_point_constants ("UACCUM", "UK",
unsigned_accum_type_node);
builtin_define_fixed_point_constants ("LACCUM", "LK",
long_accum_type_node);
builtin_define_fixed_point_constants ("ULACCUM", "ULK",
unsigned_long_accum_type_node);
builtin_define_fixed_point_constants ("LLACCUM", "LLK",
long_long_accum_type_node);
builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
unsigned_long_long_accum_type_node);
builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
builtin_define_fixed_point_constants ("HA", "", ha_type_node);
builtin_define_fixed_point_constants ("SA", "", sa_type_node);
builtin_define_fixed_point_constants ("DA", "", da_type_node);
builtin_define_fixed_point_constants ("TA", "", ta_type_node);
builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
builtin_define_fixed_point_constants ("USA", "", usa_type_node);
builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
}
/* For libgcc-internal use only. */
if (flag_building_libgcc)
/* For libgcc enable-execute-stack.c. */
builtin_define_with_int_value ("__LIBGCC_TRAMPOLINE_SIZE__",
TRAMPOLINE_SIZE);
/* For use in assembly language. */
builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
/* Misc. */
if (flag_gnu89_inline)
cpp_define (pfile, "__GNUC_GNU_INLINE__");
else
cpp_define (pfile, "__GNUC_STDC_INLINE__");
if (flag_no_inline)
cpp_define (pfile, "__NO_INLINE__");
if (flag_iso)
cpp_define (pfile, "__STRICT_ANSI__");
if (!flag_signed_char)
cpp_define (pfile, "__CHAR_UNSIGNED__");
if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
cpp_define (pfile, "__WCHAR_UNSIGNED__");
/* Tell source code if the compiler makes sync_compare_and_swap
builtins available. */
#ifdef HAVE_sync_compare_and_swapqi
if (HAVE_sync_compare_and_swapqi)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
#endif
#ifdef HAVE_sync_compare_and_swaphi
if (HAVE_sync_compare_and_swaphi)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
#endif
#ifdef HAVE_sync_compare_and_swapsi
if (HAVE_sync_compare_and_swapsi)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
#endif
#ifdef HAVE_sync_compare_and_swapdi
if (HAVE_sync_compare_and_swapdi)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
#endif
#ifdef HAVE_sync_compare_and_swapti
if (HAVE_sync_compare_and_swapti)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
#endif
cpp_atomic_builtins (pfile);
#ifdef DWARF2_UNWIND_INFO
if (dwarf2out_do_cfi_asm ())
cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
#endif
/* Make the choice of ObjC runtime visible to source code. */
if (c_dialect_objc () && flag_next_runtime)
cpp_define (pfile, "__NEXT_RUNTIME__");
/* Show the availability of some target pragmas. */
cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
/* Make the choice of the stack protector runtime visible to source code.
The macro names and values here were chosen for compatibility with an
earlier implementation, i.e. ProPolice. */
if (flag_stack_protect == 3)
cpp_define (pfile, "__SSP_STRONG__=3");
if (flag_stack_protect == 2)
cpp_define (pfile, "__SSP_ALL__=2");
else if (flag_stack_protect == 1)
cpp_define (pfile, "__SSP__=1");
if (flag_openmp)
cpp_define (pfile, "_OPENMP=201307");
if (int128_integer_type_node != NULL_TREE)
builtin_define_type_sizeof ("__SIZEOF_INT128__",
int128_integer_type_node);
builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
unsigned_ptrdiff_type_node);
/* A straightforward target hook doesn't work, because of problems
linking that hook's body when part of non-C front ends. */
# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
# define builtin_define(TXT) cpp_define (pfile, TXT)
# define builtin_assert(TXT) cpp_assert (pfile, TXT)
TARGET_CPU_CPP_BUILTINS ();
TARGET_OS_CPP_BUILTINS ();
TARGET_OBJFMT_CPP_BUILTINS ();
/* Support the __declspec keyword by turning them into attributes.
Note that the current way we do this may result in a collision
with predefined attributes later on. This can be solved by using
one attribute, say __declspec__, and passing args to it. The
problem with that approach is that args are not accumulated: each
new appearance would clobber any existing args. */
if (TARGET_DECLSPEC)
builtin_define ("__declspec(x)=__attribute__((x))");
/* If decimal floating point is supported, tell the user if the
alternate format (BID) is used instead of the standard (DPD)
format. */
if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
if (c_dialect_cxx () && flag_sized_delete)
cpp_define (pfile, "__GXX_DELETE_WITH_SIZE__");
}
struct c_expr
c_parser_binary_expression (c_parser *parser, struct c_expr *after)
{
/* A binary expression is parsed using operator-precedence parsing,
with the operands being cast expressions. All the binary
operators are left-associative. Thus a binary expression is of
form:
E0 op1 E1 op2 E2 ...
which we represent on a stack. On the stack, the precedence
levels are strictly increasing. When a new operator is
encountered of higher precedence than that at the top of the
stack, it is pushed; its LHS is the top expression, and its RHS
is everything parsed until it is popped. When a new operator is
encountered with precedence less than or equal to that at the top
of the stack, triples E[i-1] op[i] E[i] are popped and replaced
by the result of the operation until the operator at the top of
the stack has lower precedence than the new operator or there is
only one element on the stack; then the top expression is the LHS
of the new operator. In the case of logical AND and OR
expressions, we also need to adjust skip_evaluation as
appropriate when the operators are pushed and popped. */
/* The precedence levels, where 0 is a dummy lowest level used for
the bottom of the stack. */
enum prec {
PREC_NONE,
PREC_LOGOR,
PREC_LOGAND,
PREC_BITOR,
PREC_BITXOR,
PREC_BITAND,
PREC_LOGNOT,
PREC_EQ,
PREC_REL,
PREC_SHIFT,
PREC_ADD,
PREC_MULT,
NUM_PRECS
};
struct {
/* The expression at this stack level. */
struct c_expr expr;
/* The precedence of the operator on its left, PREC_NONE at the
bottom of the stack. */
enum prec prec;
/* The operation on its left. */
#if 0
enum tree_code op;
#else
int op;
#endif
} stack[NUM_PRECS];
int sp;
#define POP \
do { \
/*switch (stack[sp].op) \
{ \
case TRUTH_ANDIF_EXPR: \
skip_evaluation -= stack[sp - 1].expr.value == truthvalue_false_node; \
break; \
case TRUTH_ORIF_EXPR: \
skip_evaluation -= stack[sp - 1].expr.value == truthvalue_true_node; \
break; \
default: \
break; \
}*/ \
stack[sp - 1].expr \
= default_function_array_conversion (stack[sp - 1].expr); \
stack[sp].expr \
= default_function_array_conversion (stack[sp].expr); \
stack[sp - 1].expr = parser_build_binary_op (stack[sp].op, \
stack[sp - 1].expr, \
stack[sp].expr); \
sp--; \
} while (0)
#if 0
gcc_assert (!after || c_dialect_objc ());
#endif
;
stack[0].expr = c_parser_cast_expression (parser, after);
stack[0].prec = PREC_NONE;
sp = 0;
while (true)
{
enum prec oprec;
#if 0
enum tree_code ocode;
#else
int ocode;
#endif
if (parser->error)
goto out;
switch (c_parser_peek_token (parser)->type)
{
case '*':
case CPP_MULT:
oprec = PREC_MULT;
ocode = MULT_EXPR;
break;
#if 0
case '/':
case CPP_DIV:
oprec = PREC_MULT;
ocode = TRUNC_DIV_EXPR;
break;
case CPP_MOD:
oprec = PREC_MULT;
ocode = TRUNC_MOD_EXPR;
break;
#endif
case '+':
case CPP_PLUS:
oprec = PREC_ADD;
ocode = PLUS_EXPR;
break;
case '-':
case CPP_MINUS:
oprec = PREC_ADD;
ocode = MINUS_EXPR;
break;
#if 0
case CPP_LSHIFT:
oprec = PREC_SHIFT;
ocode = LSHIFT_EXPR;
break;
case CPP_RSHIFT:
oprec = PREC_SHIFT;
ocode = RSHIFT_EXPR;
break;
#endif
case K_LT:
case CPP_LESS:
oprec = PREC_REL;
ocode = LT_EXPR;
break;
case K_GT:
case CPP_GREATER:
oprec = PREC_REL;
ocode = GT_EXPR;
break;
case K_LE:
case CPP_LESS_EQ:
oprec = PREC_REL;
ocode = LE_EXPR;
break;
case K_GE:
case CPP_GREATER_EQ:
oprec = PREC_REL;
ocode = GE_EXPR;
break;
case K_EQ:
case CPP_EQ_EQ:
oprec = PREC_EQ;
ocode = EQ_EXPR;
break;
case K_NE:
case CPP_NOT_EQ:
oprec = PREC_EQ;
ocode = NE_EXPR;
break;
case K_EQS:
case K_NES:
case K_LES:
case K_LTS:
case K_GES:
case K_GTS:
oprec = PREC_EQ;
ocode = c_parser_peek_token (parser)->type;
break;
case K_AND:
case CPP_AND:
oprec = PREC_BITAND;
ocode = BIT_AND_EXPR;
break;
case CPP_XOR:
oprec = PREC_BITXOR;
ocode = BIT_XOR_EXPR;
break;
case K_OR:
case CPP_OR:
oprec = PREC_BITOR;
ocode = BIT_IOR_EXPR;
break;
case CPP_AND_AND:
oprec = PREC_LOGAND;
ocode = TRUTH_ANDIF_EXPR;
break;
case CPP_OR_OR:
oprec = PREC_LOGOR;
ocode = TRUTH_ORIF_EXPR;
break;
default:
/* Not a binary operator, so end of the binary
expression. */
goto out;
}
c_parser_consume_token (parser);
while (oprec <= stack[sp].prec)
POP;
switch (ocode)
{
#if 0
case TRUTH_ANDIF_EXPR:
stack[sp].expr
= default_function_array_conversion (stack[sp].expr);
stack[sp].expr.value = c_objc_common_truthvalue_conversion
(default_conversion (stack[sp].expr.value));
skip_evaluation += stack[sp].expr.value == truthvalue_false_node;
break;
case TRUTH_ORIF_EXPR:
stack[sp].expr
= default_function_array_conversion (stack[sp].expr);
stack[sp].expr.value = c_objc_common_truthvalue_conversion
(default_conversion (stack[sp].expr.value));
skip_evaluation += stack[sp].expr.value == truthvalue_true_node;
break;
#endif
default:
break;
}
sp++;
stack[sp].expr = c_parser_cast_expression (parser, NULL);
stack[sp].prec = oprec;
stack[sp].op = ocode;
}
out:
while (sp > 0)
POP;
return stack[0].expr;
#undef POP
}
static void
c_lex_one_token (c_token *token)
{
#if 0
timevar_push (TV_LEX);
token->type = c_lex_with_flags (&token->value, &token->location, NULL);
#else
token->type = clilex();
token->value = yylval.type_node_p;
#endif
token->in_system_header = in_system_header;
switch (token->type)
{
case T_NAME:
case CPP_NAME:
token->id_kind = C_ID_NONE;
token->keyword = RID_MAX;
{
tree decl;
int objc_force_identifier = objc_need_raw_identifier;
#if 0
OBJC_NEED_RAW_IDENTIFIER (0);
#endif
if (0/*C_IS_RESERVED_WORD (token->value)*/)
{
enum rid rid_code = 0/*C_RID_CODE (token->value)*/;
#if 0
if (c_dialect_objc ())
{
if (!OBJC_IS_AT_KEYWORD (rid_code)
&& (!OBJC_IS_PQ_KEYWORD (rid_code) || objc_pq_context))
{
/* Return the canonical spelling for this keyword. */
token->value = ridpointers[(int) rid_code];
token->type = CPP_KEYWORD;
token->keyword = rid_code;
break;
}
}
else
#endif
{
/* Return the canonical spelling for this keyword. */
#if 0
token->value = ridpointers[(int) rid_code];
#endif
token->type = CPP_KEYWORD;
token->keyword = rid_code;
break;
}
}
#if 0
decl = lookup_name (token->value);
if (decl)
{
if (TREE_CODE (decl) == TYPE_DECL)
{
token->id_kind = C_ID_TYPENAME;
break;
}
}
#if 0
else if (c_dialect_objc ())
{
tree objc_interface_decl = objc_is_class_name (token->value);
/* Objective-C class names are in the same namespace as
variables and typedefs, and hence are shadowed by local
declarations. */
if (objc_interface_decl
&& (global_bindings_p ()
|| (!objc_force_identifier && !decl)))
{
token->value = objc_interface_decl;
token->id_kind = C_ID_CLASSNAME;
break;
}
}
#endif
#endif
}
token->id_kind = C_ID_ID;
break;
#if 0
case CPP_AT_NAME:
/* This only happens in Objective-C; it must be a keyword. */
token->type = CPP_KEYWORD;
token->id_kind = C_ID_NONE;
token->keyword = C_RID_CODE (token->value);
break;
#endif
case ':':
case ',':
case ')':
case ';':
case CPP_COLON:
case CPP_COMMA:
case CPP_CLOSE_PAREN:
case CPP_SEMICOLON:
/* These tokens may affect the interpretation of any identifiers
following, if doing Objective-C. */
#if 0
OBJC_NEED_RAW_IDENTIFIER (0);
#endif
token->id_kind = C_ID_NONE;
token->keyword = RID_MAX;
break;
default:
token->id_kind = C_ID_NONE;
token->keyword = RID_MAX;
break;
}
#if 0
timevar_pop (TV_LEX);
#endif
}
/* Hook that registers front end and target-specific built-ins. */
void
c_cpp_builtins (cpp_reader *pfile)
{
/* -undef turns off target-specific built-ins. */
if (flag_undef)
return;
define__GNUC__ ();
/* For stddef.h. They require macros defined in c-common.c. */
c_stddef_cpp_builtins ();
if (c_dialect_cxx ())
{
if (SUPPORTS_ONE_ONLY)
cpp_define (pfile, "__GXX_WEAK__=1");
else
cpp_define (pfile, "__GXX_WEAK__=0");
if (warn_deprecated)
cpp_define (pfile, "__DEPRECATED");
}
/* Note that we define this for C as well, so that we know if
__attribute__((cleanup)) will interface with EH. */
if (flag_exceptions)
cpp_define (pfile, "__EXCEPTIONS");
/* Represents the C++ ABI version, always defined so it can be used while
preprocessing C and assembler. */
if (flag_abi_version == 0)
/* Use a very large value so that:
#if __GXX_ABI_VERSION >= <value for version X>
will work whether the user explicitly says "-fabi-version=x" or
"-fabi-version=0". Do not use INT_MAX because that will be
different from system to system. */
builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
else if (flag_abi_version == 1)
/* Due to an historical accident, this version had the value
"102". */
builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
else
/* Newer versions have values 1002, 1003, .... */
builtin_define_with_int_value ("__GXX_ABI_VERSION",
1000 + flag_abi_version);
/* libgcc needs to know this. */
if (USING_SJLJ_EXCEPTIONS)
cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
/* limits.h needs to know these. */
builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
/* float.h needs to know these. */
builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
TARGET_FLT_EVAL_METHOD);
builtin_define_float_constants ("FLT", "F", float_type_node);
builtin_define_float_constants ("DBL", "", double_type_node);
builtin_define_float_constants ("LDBL", "L", long_double_type_node);
/* For use in assembly language. */
builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
/* Misc. */
builtin_define_with_value ("__VERSION__", version_string, 1);
/* Definitions for LP64 model. */
if (TYPE_PRECISION (long_integer_type_node) == 64
&& POINTER_SIZE == 64
&& TYPE_PRECISION (integer_type_node) == 32)
{
cpp_define (pfile, "_LP64");
cpp_define (pfile, "__LP64__");
}
/* Other target-independent built-ins determined by command-line
options. */
if (optimize_size)
cpp_define (pfile, "__OPTIMIZE_SIZE__");
if (optimize)
cpp_define (pfile, "__OPTIMIZE__");
if (fast_math_flags_set_p ())
cpp_define (pfile, "__FAST_MATH__");
if (flag_really_no_inline)
cpp_define (pfile, "__NO_INLINE__");
if (flag_signaling_nans)
cpp_define (pfile, "__SUPPORT_SNAN__");
if (flag_finite_math_only)
cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
else
cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
if (flag_iso)
cpp_define (pfile, "__STRICT_ANSI__");
if (!flag_signed_char)
cpp_define (pfile, "__CHAR_UNSIGNED__");
if (c_dialect_cxx () && TREE_UNSIGNED (wchar_type_node))
cpp_define (pfile, "__WCHAR_UNSIGNED__");
/* Make the choice of ObjC runtime visible to source code. */
if (c_dialect_objc () && flag_next_runtime)
cpp_define (pfile, "__NEXT_RUNTIME__");
/* A straightforward target hook doesn't work, because of problems
linking that hook's body when part of non-C front ends. */
# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
# define builtin_define(TXT) cpp_define (pfile, TXT)
# define builtin_assert(TXT) cpp_assert (pfile, TXT)
TARGET_CPU_CPP_BUILTINS ();
TARGET_OS_CPP_BUILTINS ();
TARGET_OBJFMT_CPP_BUILTINS ();
}
/* Hook that registers front end and target-specific built-ins. */
void
c_cpp_builtins (cpp_reader *pfile)
{
/* -undef turns off target-specific built-ins. */
if (flag_undef)
return;
define__GNUC__ ();
/* For stddef.h. They require macros defined in c-common.c. */
c_stddef_cpp_builtins ();
if (c_dialect_cxx ())
{
if (flag_weak && SUPPORTS_ONE_ONLY)
cpp_define (pfile, "__GXX_WEAK__=1");
else
cpp_define (pfile, "__GXX_WEAK__=0");
if (warn_deprecated)
cpp_define (pfile, "__DEPRECATED");
if (flag_rtti)
cpp_define (pfile, "__GXX_RTTI");
if (cxx_dialect == cxx0x)
cpp_define (pfile, "__GXX_EXPERIMENTAL_CXX0X__");
}
/* Note that we define this for C as well, so that we know if
__attribute__((cleanup)) will interface with EH. */
if (flag_exceptions)
cpp_define (pfile, "__EXCEPTIONS");
/* Represents the C++ ABI version, always defined so it can be used while
preprocessing C and assembler. */
if (flag_abi_version == 0)
/* Use a very large value so that:
#if __GXX_ABI_VERSION >= <value for version X>
will work whether the user explicitly says "-fabi-version=x" or
"-fabi-version=0". Do not use INT_MAX because that will be
different from system to system. */
builtin_define_with_int_value ("__GXX_ABI_VERSION", 999999);
else if (flag_abi_version == 1)
/* Due to a historical accident, this version had the value
"102". */
builtin_define_with_int_value ("__GXX_ABI_VERSION", 102);
else
/* Newer versions have values 1002, 1003, .... */
builtin_define_with_int_value ("__GXX_ABI_VERSION",
1000 + flag_abi_version);
/* libgcc needs to know this. */
if (USING_SJLJ_EXCEPTIONS)
cpp_define (pfile, "__USING_SJLJ_EXCEPTIONS__");
/* limits.h needs to know these. */
builtin_define_type_max ("__SCHAR_MAX__", signed_char_type_node, 0);
builtin_define_type_max ("__SHRT_MAX__", short_integer_type_node, 0);
builtin_define_type_max ("__INT_MAX__", integer_type_node, 0);
builtin_define_type_max ("__LONG_MAX__", long_integer_type_node, 1);
builtin_define_type_max ("__LONG_LONG_MAX__", long_long_integer_type_node, 2);
builtin_define_type_max ("__WCHAR_MAX__", wchar_type_node, 0);
builtin_define_type_precision ("__CHAR_BIT__", char_type_node);
/* stdint.h (eventually) and the testsuite need to know these. */
builtin_define_stdint_macros ();
/* float.h needs to know these. */
builtin_define_with_int_value ("__FLT_EVAL_METHOD__",
TARGET_FLT_EVAL_METHOD);
/* And decfloat.h needs this. */
builtin_define_with_int_value ("__DEC_EVAL_METHOD__",
TARGET_DEC_EVAL_METHOD);
builtin_define_float_constants ("FLT", "F", "%s", float_type_node);
/* Cast the double precision constants when single precision constants are
specified. The correct result is computed by the compiler when using
macros that include a cast. This has the side-effect of making the value
unusable in const expressions. */
if (flag_single_precision_constant)
builtin_define_float_constants ("DBL", "L", "((double)%s)", double_type_node);
else
builtin_define_float_constants ("DBL", "", "%s", double_type_node);
builtin_define_float_constants ("LDBL", "L", "%s", long_double_type_node);
/* For decfloat.h. */
builtin_define_decimal_float_constants ("DEC32", "DF", dfloat32_type_node);
builtin_define_decimal_float_constants ("DEC64", "DD", dfloat64_type_node);
builtin_define_decimal_float_constants ("DEC128", "DL", dfloat128_type_node);
/* For fixed-point fibt, ibit, max, min, and epsilon. */
if (targetm.fixed_point_supported_p ())
{
builtin_define_fixed_point_constants ("SFRACT", "HR",
short_fract_type_node);
builtin_define_fixed_point_constants ("USFRACT", "UHR",
unsigned_short_fract_type_node);
builtin_define_fixed_point_constants ("FRACT", "R",
fract_type_node);
builtin_define_fixed_point_constants ("UFRACT", "UR",
unsigned_fract_type_node);
builtin_define_fixed_point_constants ("LFRACT", "LR",
long_fract_type_node);
builtin_define_fixed_point_constants ("ULFRACT", "ULR",
unsigned_long_fract_type_node);
builtin_define_fixed_point_constants ("LLFRACT", "LLR",
long_long_fract_type_node);
builtin_define_fixed_point_constants ("ULLFRACT", "ULLR",
unsigned_long_long_fract_type_node);
builtin_define_fixed_point_constants ("SACCUM", "HK",
short_accum_type_node);
builtin_define_fixed_point_constants ("USACCUM", "UHK",
unsigned_short_accum_type_node);
builtin_define_fixed_point_constants ("ACCUM", "K",
accum_type_node);
builtin_define_fixed_point_constants ("UACCUM", "UK",
unsigned_accum_type_node);
builtin_define_fixed_point_constants ("LACCUM", "LK",
long_accum_type_node);
builtin_define_fixed_point_constants ("ULACCUM", "ULK",
unsigned_long_accum_type_node);
builtin_define_fixed_point_constants ("LLACCUM", "LLK",
long_long_accum_type_node);
builtin_define_fixed_point_constants ("ULLACCUM", "ULLK",
unsigned_long_long_accum_type_node);
builtin_define_fixed_point_constants ("QQ", "", qq_type_node);
builtin_define_fixed_point_constants ("HQ", "", hq_type_node);
builtin_define_fixed_point_constants ("SQ", "", sq_type_node);
builtin_define_fixed_point_constants ("DQ", "", dq_type_node);
builtin_define_fixed_point_constants ("TQ", "", tq_type_node);
builtin_define_fixed_point_constants ("UQQ", "", uqq_type_node);
builtin_define_fixed_point_constants ("UHQ", "", uhq_type_node);
builtin_define_fixed_point_constants ("USQ", "", usq_type_node);
builtin_define_fixed_point_constants ("UDQ", "", udq_type_node);
builtin_define_fixed_point_constants ("UTQ", "", utq_type_node);
builtin_define_fixed_point_constants ("HA", "", ha_type_node);
builtin_define_fixed_point_constants ("SA", "", sa_type_node);
builtin_define_fixed_point_constants ("DA", "", da_type_node);
builtin_define_fixed_point_constants ("TA", "", ta_type_node);
builtin_define_fixed_point_constants ("UHA", "", uha_type_node);
builtin_define_fixed_point_constants ("USA", "", usa_type_node);
builtin_define_fixed_point_constants ("UDA", "", uda_type_node);
builtin_define_fixed_point_constants ("UTA", "", uta_type_node);
}
/* For use in assembly language. */
builtin_define_with_value ("__REGISTER_PREFIX__", REGISTER_PREFIX, 0);
builtin_define_with_value ("__USER_LABEL_PREFIX__", user_label_prefix, 0);
/* Misc. */
builtin_define_with_value ("__VERSION__", version_string, 1);
if (flag_gnu89_inline)
cpp_define (pfile, "__GNUC_GNU_INLINE__");
else
cpp_define (pfile, "__GNUC_STDC_INLINE__");
/* Definitions for LP64 model. */
if (TYPE_PRECISION (long_integer_type_node) == 64
&& POINTER_SIZE == 64
&& TYPE_PRECISION (integer_type_node) == 32)
{
cpp_define (pfile, "_LP64");
cpp_define (pfile, "__LP64__");
}
/* Other target-independent built-ins determined by command-line
options. */
if (optimize_size)
cpp_define (pfile, "__OPTIMIZE_SIZE__");
if (optimize)
cpp_define (pfile, "__OPTIMIZE__");
if (fast_math_flags_set_p ())
cpp_define (pfile, "__FAST_MATH__");
if (flag_no_inline)
cpp_define (pfile, "__NO_INLINE__");
if (flag_signaling_nans)
cpp_define (pfile, "__SUPPORT_SNAN__");
if (flag_finite_math_only)
cpp_define (pfile, "__FINITE_MATH_ONLY__=1");
else
cpp_define (pfile, "__FINITE_MATH_ONLY__=0");
if (flag_pic)
{
builtin_define_with_int_value ("__pic__", flag_pic);
builtin_define_with_int_value ("__PIC__", flag_pic);
}
if (flag_pie)
{
builtin_define_with_int_value ("__pie__", flag_pie);
builtin_define_with_int_value ("__PIE__", flag_pie);
}
if (flag_iso)
cpp_define (pfile, "__STRICT_ANSI__");
if (!flag_signed_char)
cpp_define (pfile, "__CHAR_UNSIGNED__");
if (c_dialect_cxx () && TYPE_UNSIGNED (wchar_type_node))
cpp_define (pfile, "__WCHAR_UNSIGNED__");
/* Define a macro indicating whether the thread safety attributes/analysis
is supported. */
if (warn_thread_safety)
{
cpp_define (pfile, "__SUPPORT_TS_ANNOTATION__");
cpp_define (pfile, "__SUPPORT_DYN_ANNOTATION__");
}
/* Tell source code if the compiler makes sync_compare_and_swap
builtins available. */
#ifdef HAVE_sync_compare_and_swapqi
if (HAVE_sync_compare_and_swapqi)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_1");
#endif
#ifdef HAVE_sync_compare_and_swaphi
if (HAVE_sync_compare_and_swaphi)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_2");
#endif
#ifdef HAVE_sync_compare_and_swapsi
if (HAVE_sync_compare_and_swapsi)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_4");
#endif
#ifdef HAVE_sync_compare_and_swapdi
if (HAVE_sync_compare_and_swapdi)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_8");
#endif
#ifdef HAVE_sync_compare_and_swapti
if (HAVE_sync_compare_and_swapti)
cpp_define (pfile, "__GCC_HAVE_SYNC_COMPARE_AND_SWAP_16");
#endif
#ifdef DWARF2_UNWIND_INFO
if (dwarf2out_do_cfi_asm ())
cpp_define (pfile, "__GCC_HAVE_DWARF2_CFI_ASM");
#endif
/* Make the choice of ObjC runtime visible to source code. */
if (c_dialect_objc () && flag_next_runtime)
cpp_define (pfile, "__NEXT_RUNTIME__");
/* Show the availability of some target pragmas. */
if (flag_mudflap || targetm.handle_pragma_redefine_extname)
cpp_define (pfile, "__PRAGMA_REDEFINE_EXTNAME");
if (targetm.handle_pragma_extern_prefix)
cpp_define (pfile, "__PRAGMA_EXTERN_PREFIX");
/* Make the choice of the stack protector runtime visible to source code.
The macro names and values here were chosen for compatibility with an
earlier implementation, i.e. ProPolice. */
if (flag_stack_protect == 2)
cpp_define (pfile, "__SSP_ALL__=2");
else if (flag_stack_protect == 1)
cpp_define (pfile, "__SSP__=1");
if (flag_openmp)
cpp_define (pfile, "_OPENMP=200805");
builtin_define_type_sizeof ("__SIZEOF_INT__", integer_type_node);
builtin_define_type_sizeof ("__SIZEOF_LONG__", long_integer_type_node);
builtin_define_type_sizeof ("__SIZEOF_LONG_LONG__",
long_long_integer_type_node);
builtin_define_type_sizeof ("__SIZEOF_SHORT__", short_integer_type_node);
builtin_define_type_sizeof ("__SIZEOF_FLOAT__", float_type_node);
builtin_define_type_sizeof ("__SIZEOF_DOUBLE__", double_type_node);
builtin_define_type_sizeof ("__SIZEOF_LONG_DOUBLE__", long_double_type_node);
builtin_define_type_sizeof ("__SIZEOF_SIZE_T__", size_type_node);
builtin_define_type_sizeof ("__SIZEOF_WCHAR_T__", wchar_type_node);
builtin_define_type_sizeof ("__SIZEOF_WINT_T__", wint_type_node);
builtin_define_type_sizeof ("__SIZEOF_PTRDIFF_T__",
unsigned_ptrdiff_type_node);
/* ptr_type_node can't be used here since ptr_mode is only set when
toplev calls backend_init which is not done with -E switch. */
builtin_define_with_int_value ("__SIZEOF_POINTER__",
POINTER_SIZE / BITS_PER_UNIT);
/* A straightforward target hook doesn't work, because of problems
linking that hook's body when part of non-C front ends. */
# define preprocessing_asm_p() (cpp_get_options (pfile)->lang == CLK_ASM)
# define preprocessing_trad_p() (cpp_get_options (pfile)->traditional)
# define builtin_define(TXT) cpp_define (pfile, TXT)
# define builtin_assert(TXT) cpp_assert (pfile, TXT)
TARGET_CPU_CPP_BUILTINS ();
TARGET_OS_CPP_BUILTINS ();
TARGET_OBJFMT_CPP_BUILTINS ();
/* Support the __declspec keyword by turning them into attributes.
Note that the current way we do this may result in a collision
with predefined attributes later on. This can be solved by using
one attribute, say __declspec__, and passing args to it. The
problem with that approach is that args are not accumulated: each
new appearance would clobber any existing args. */
if (TARGET_DECLSPEC)
builtin_define ("__declspec(x)=__attribute__((x))");
/* If decimal floating point is supported, tell the user if the
alternate format (BID) is used instead of the standard (DPD)
format. */
if (ENABLE_DECIMAL_FLOAT && ENABLE_DECIMAL_BID_FORMAT)
cpp_define (pfile, "__DECIMAL_BID_FORMAT__");
builtin_define_with_int_value ("__BIGGEST_ALIGNMENT__",
BIGGEST_ALIGNMENT / BITS_PER_UNIT);
}
