mirror of
git://gcc.gnu.org/git/gcc.git
synced 2025-04-11 21:31:32 +08:00
89th Cygnus<->FSF quick merge
From-SVN: r12953
This commit is contained in:
Mike Stump
parent
3d4683cb70
commit
d22c85969b
105
gcc/cp/decl.c
105
gcc/cp/decl.c
@ -562,7 +562,7 @@ struct binding_level
|
||||
|
||||
/* List of VAR_DECLS saved from a previous for statement.
|
||||
These would be dead in ANSI-conforming code, but might
|
||||
be referenced in traditional code. */
|
||||
be referenced in ARM-era code. */
|
||||
tree dead_vars_from_for;
|
||||
|
||||
/* 1 for the level that holds the parameters of a function.
|
||||
@ -591,7 +591,7 @@ struct binding_level
|
||||
unsigned namespace_p : 1;
|
||||
|
||||
/* True if this level is that of a for-statement where we need to
|
||||
worry about ambiguous (traditional or ANSI) scope rules. */
|
||||
worry about ambiguous (ARM or ANSI) scope rules. */
|
||||
unsigned is_for_scope : 1;
|
||||
|
||||
/* Two bits left for this word. */
|
||||
@ -2067,16 +2067,6 @@ pushtag (name, type, globalize)
|
||||
newdecl = 1;
|
||||
d = build_decl (TYPE_DECL, name, type);
|
||||
SET_DECL_ARTIFICIAL (d);
|
||||
#ifdef DWARF_DEBUGGING_INFO
|
||||
if (write_symbols == DWARF_DEBUG)
|
||||
{
|
||||
/* Mark the TYPE_DECL node we created just above as an
|
||||
gratuitous one. We need to do this so that dwarfout.c
|
||||
will understand that it is not supposed to output a
|
||||
TAG_typedef DIE for it. */
|
||||
DECL_IGNORED_P (d) = 1;
|
||||
}
|
||||
#endif /* DWARF_DEBUGGING_INFO */
|
||||
set_identifier_type_value_with_scope (name, type, b);
|
||||
}
|
||||
else
|
||||
@ -2103,17 +2093,6 @@ pushtag (name, type, globalize)
|
||||
newdecl = 1;
|
||||
d = build_decl (TYPE_DECL, name, type);
|
||||
SET_DECL_ARTIFICIAL (d);
|
||||
#ifdef DWARF_DEBUGGING_INFO
|
||||
if (write_symbols == DWARF_DEBUG)
|
||||
{
|
||||
/* Mark the TYPE_DECL node we created just above as an
|
||||
gratuitous one. We need to do this so that dwarfout.c
|
||||
will understand that it is not supposed to output a
|
||||
TAG_typedef DIE for it. */
|
||||
DECL_IGNORED_P (d) = 1;
|
||||
}
|
||||
#endif /* DWARF_DEBUGGING_INFO */
|
||||
|
||||
TYPE_MAIN_DECL (type) = d;
|
||||
DECL_CONTEXT (d) = context;
|
||||
if (! globalize && processing_template_decl && IS_AGGR_TYPE (type))
|
||||
@ -2334,9 +2313,6 @@ decls_match (newdecl, olddecl)
|
||||
Note that this does not apply to the C++ case of declaring
|
||||
a variable `extern const' and then later `const'.
|
||||
|
||||
Don't complain if -traditional, since traditional compilers
|
||||
don't complain.
|
||||
|
||||
Don't complain about built-in functions, since they are beyond
|
||||
the user's control. */
|
||||
|
||||
@ -2351,8 +2327,7 @@ warn_extern_redeclared_static (newdecl, olddecl)
|
||||
static char *implicit_extern_static_warning
|
||||
= "`%D' was declared implicitly `extern' and later `static'";
|
||||
|
||||
if (flag_traditional
|
||||
|| TREE_CODE (newdecl) == TYPE_DECL)
|
||||
if (TREE_CODE (newdecl) == TYPE_DECL)
|
||||
return;
|
||||
|
||||
name = DECL_ASSEMBLER_NAME (newdecl);
|
||||
@ -2413,14 +2388,9 @@ duplicate_decls (newdecl, olddecl)
|
||||
&& TREE_CODE (TREE_TYPE (olddecl)) == ERROR_MARK))
|
||||
types_match = 1;
|
||||
|
||||
if (flag_traditional && TREE_CODE (newdecl) == FUNCTION_DECL
|
||||
&& IDENTIFIER_IMPLICIT_DECL (DECL_ASSEMBLER_NAME (newdecl)) == olddecl)
|
||||
/* If -traditional, avoid error for redeclaring fcn
|
||||
after implicit decl. */
|
||||
;
|
||||
else if (TREE_CODE (olddecl) == FUNCTION_DECL
|
||||
&& DECL_ARTIFICIAL (olddecl)
|
||||
&& (DECL_BUILT_IN (olddecl) || DECL_BUILT_IN_NONANSI (olddecl)))
|
||||
if (TREE_CODE (olddecl) == FUNCTION_DECL
|
||||
&& DECL_ARTIFICIAL (olddecl)
|
||||
&& (DECL_BUILT_IN (olddecl) || DECL_BUILT_IN_NONANSI (olddecl)))
|
||||
{
|
||||
/* If you declare a built-in or predefined function name as static,
|
||||
the old definition is overridden, but optionally warn this was a
|
||||
@ -2917,13 +2887,17 @@ duplicate_decls (newdecl, olddecl)
|
||||
|
||||
obstack_free (&permanent_obstack, newdecl);
|
||||
}
|
||||
else if (LANG_DECL_PERMANENT (ol))
|
||||
else if (LANG_DECL_PERMANENT (ol) && ol != nl)
|
||||
{
|
||||
if (DECL_MAIN_VARIANT (olddecl) == olddecl)
|
||||
{
|
||||
/* Save these lang_decls that would otherwise be lost. */
|
||||
extern tree free_lang_decl_chain;
|
||||
tree free_lang_decl = (tree) ol;
|
||||
|
||||
if (DECL_LANG_SPECIFIC (olddecl) == ol)
|
||||
abort ();
|
||||
|
||||
TREE_CHAIN (free_lang_decl) = free_lang_decl_chain;
|
||||
free_lang_decl_chain = free_lang_decl;
|
||||
}
|
||||
@ -3160,12 +3134,6 @@ pushdecl (x)
|
||||
}
|
||||
}
|
||||
|
||||
/* In PCC-compatibility mode, extern decls of vars with no current decl
|
||||
take effect at top level no matter where they are. */
|
||||
if (flag_traditional && DECL_EXTERNAL (x)
|
||||
&& lookup_name (name, 0) == NULL_TREE)
|
||||
b = global_binding_level;
|
||||
|
||||
/* This name is new in its binding level.
|
||||
Install the new declaration and return it. */
|
||||
if (b == global_binding_level)
|
||||
@ -3625,7 +3593,7 @@ implicitly_declare (functionid)
|
||||
/* Save the decl permanently so we can warn if definition follows.
|
||||
In ANSI C, warn_implicit is usually false, so the saves little space.
|
||||
But in C++, it's usually true, hence the extra code. */
|
||||
if (temp && (flag_traditional || !warn_implicit || toplevel_bindings_p ()))
|
||||
if (temp && (! warn_implicit || toplevel_bindings_p ()))
|
||||
end_temporary_allocation ();
|
||||
|
||||
/* We used to reuse an old implicit decl here,
|
||||
@ -3637,8 +3605,7 @@ implicitly_declare (functionid)
|
||||
TREE_PUBLIC (decl) = 1;
|
||||
|
||||
/* ANSI standard says implicit declarations are in the innermost block.
|
||||
So we record the decl in the standard fashion.
|
||||
If flag_traditional is set, pushdecl does it top-level. */
|
||||
So we record the decl in the standard fashion. */
|
||||
pushdecl (decl);
|
||||
rest_of_decl_compilation (decl, NULL_PTR, 0, 0);
|
||||
|
||||
@ -4695,8 +4662,6 @@ init_decl_processing ()
|
||||
tree decl;
|
||||
register tree endlink, int_endlink, double_endlink;
|
||||
tree fields[20];
|
||||
/* Either char* or void*. */
|
||||
tree traditional_ptr_type_node;
|
||||
/* Data type of memcpy. */
|
||||
tree memcpy_ftype, strlen_ftype;
|
||||
int wchar_type_size;
|
||||
@ -4819,13 +4784,10 @@ init_decl_processing ()
|
||||
record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
|
||||
|
||||
/* `unsigned long' is the standard type for sizeof.
|
||||
Traditionally, use a signed type.
|
||||
Note that stddef.h uses `unsigned long',
|
||||
and this must agree, even of long and int are the same size. */
|
||||
sizetype
|
||||
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (SIZE_TYPE)));
|
||||
if (flag_traditional && TREE_UNSIGNED (sizetype))
|
||||
sizetype = signed_type (sizetype);
|
||||
|
||||
ptrdiff_type_node
|
||||
= TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (get_identifier (PTRDIFF_TYPE)));
|
||||
@ -5017,11 +4979,8 @@ init_decl_processing ()
|
||||
tree_cons (NULL_TREE, const_string_type_node,
|
||||
endlink));
|
||||
|
||||
traditional_ptr_type_node
|
||||
= (flag_traditional ? string_type_node : ptr_type_node);
|
||||
|
||||
memcpy_ftype /* memcpy prototype */
|
||||
= build_function_type (traditional_ptr_type_node,
|
||||
= build_function_type (ptr_type_node,
|
||||
tree_cons (NULL_TREE, ptr_type_node,
|
||||
tree_cons (NULL_TREE, const_ptr_type_node,
|
||||
tree_cons (NULL_TREE,
|
||||
@ -6546,8 +6505,7 @@ cp_finish_decl (decl, init, asmspec_tree, need_pop, flags)
|
||||
/* ??? FIXME: What about nested classes? */
|
||||
int toplev = toplevel_bindings_p () || pseudo_global_level_p ();
|
||||
int was_temp
|
||||
= ((flag_traditional
|
||||
|| (TREE_STATIC (decl) && TYPE_NEEDS_DESTRUCTOR (type)))
|
||||
= (TREE_STATIC (decl) && TYPE_NEEDS_DESTRUCTOR (type)
|
||||
&& allocation_temporary_p ());
|
||||
|
||||
if (was_temp)
|
||||
@ -6709,7 +6667,7 @@ cp_finish_decl (decl, init, asmspec_tree, need_pop, flags)
|
||||
/* Check to see if the same name is already bound at
|
||||
the outer level, either because it was directly declared,
|
||||
or because a dead for-decl got preserved. In either case,
|
||||
the code would not have been valid under the traditional
|
||||
the code would not have been valid under the ARM
|
||||
scope rules, so clear is_for_scope for the
|
||||
current_binding_level.
|
||||
|
||||
@ -7507,9 +7465,6 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
|
||||
else if (decl_context == BITFIELD)
|
||||
bitfield = 1, decl_context = FIELD;
|
||||
|
||||
if (flag_traditional && allocation_temporary_p ())
|
||||
end_temporary_allocation ();
|
||||
|
||||
/* Look inside a declarator for the name being declared
|
||||
and get it as a string, for an error message. */
|
||||
{
|
||||
@ -8059,8 +8014,6 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
|
||||
/* Decide whether an integer type is signed or not.
|
||||
Optionally treat bitfields as signed by default. */
|
||||
if (RIDBIT_SETP (RID_UNSIGNED, specbits)
|
||||
/* Traditionally, all bitfields are unsigned. */
|
||||
|| (bitfield && flag_traditional)
|
||||
|| (bitfield && ! flag_signed_bitfields
|
||||
&& (explicit_int || explicit_char
|
||||
/* A typedef for plain `int' without `signed'
|
||||
@ -8659,16 +8612,6 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
|
||||
name);
|
||||
}
|
||||
|
||||
/* Traditionally, declaring return type float means double. */
|
||||
|
||||
if (flag_traditional
|
||||
&& TYPE_MAIN_VARIANT (type) == float_type_node)
|
||||
{
|
||||
type = build_type_variant (double_type_node,
|
||||
TYPE_READONLY (type),
|
||||
TYPE_VOLATILE (type));
|
||||
}
|
||||
|
||||
/* Construct the function type and go to the next
|
||||
inner layer of declarator. */
|
||||
|
||||
@ -8700,10 +8643,9 @@ grokdeclarator (declarator, declspecs, decl_context, initialized, attrlist)
|
||||
}
|
||||
}
|
||||
|
||||
/* ANSI seems to say that `const int foo ();'
|
||||
/* ANSI says that `const int foo ();'
|
||||
does not make the function foo const. */
|
||||
type = build_function_type (type,
|
||||
flag_traditional ? 0 : arg_types);
|
||||
type = build_function_type (type, arg_types);
|
||||
}
|
||||
break;
|
||||
|
||||
@ -12030,10 +11972,6 @@ finish_function (lineno, call_poplevel, nested)
|
||||
/* Must mark the RESULT_DECL as being in this function. */
|
||||
DECL_CONTEXT (DECL_RESULT (fndecl)) = fndecl;
|
||||
|
||||
/* Obey `register' declarations if `setjmp' is called in this fn. */
|
||||
if (flag_traditional && current_function_calls_setjmp)
|
||||
setjmp_protect (DECL_INITIAL (fndecl));
|
||||
|
||||
/* Set the BLOCK_SUPERCONTEXT of the outermost function scope to point
|
||||
to the FUNCTION_DECL node itself. */
|
||||
BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
|
||||
@ -12108,12 +12046,7 @@ finish_function (lineno, call_poplevel, nested)
|
||||
DECL_INITIAL (fndecl) = error_mark_node;
|
||||
/* And we need the arguments for template instantiation. */
|
||||
if (! processing_template_decl)
|
||||
{
|
||||
if (! DECL_CONSTRUCTOR_P (fndecl)
|
||||
|| !(TYPE_USES_VIRTUAL_BASECLASSES
|
||||
(TYPE_METHOD_BASETYPE (fntype))))
|
||||
DECL_ARGUMENTS (fndecl) = NULL_TREE;
|
||||
}
|
||||
DECL_ARGUMENTS (fndecl) = NULL_TREE;
|
||||
}
|
||||
|
||||
if (DECL_STATIC_CONSTRUCTOR (fndecl))
|
||||
|
||||
@ -42,6 +42,7 @@ extern tree cleanups_this_call;
|
||||
static void grok_function_init PROTO((tree, tree));
|
||||
void import_export_decl ();
|
||||
extern int current_class_depth;
|
||||
extern int symout_time;
|
||||
|
||||
/* A list of virtual function tables we must make sure to write out. */
|
||||
tree pending_vtables;
|
||||
@ -104,7 +105,8 @@ int flag_no_builtin;
|
||||
|
||||
int flag_no_nonansi_builtin;
|
||||
|
||||
/* Nonzero means do some things the same way PCC does. */
|
||||
/* Nonzero means do some things the same way PCC does. Only provided so
|
||||
the compiler will link. */
|
||||
|
||||
int flag_traditional;
|
||||
|
||||
@ -184,20 +186,11 @@ int warn_cast_qual;
|
||||
|
||||
int warn_template_debugging;
|
||||
|
||||
/* Warn about traditional constructs whose meanings changed in ANSI C. */
|
||||
|
||||
int warn_traditional;
|
||||
|
||||
/* Nonzero means warn about sizeof(function) or addition/subtraction
|
||||
of function pointers. */
|
||||
|
||||
int warn_pointer_arith = 1;
|
||||
|
||||
/* Nonzero means warn for non-prototype function decls
|
||||
or non-prototyped defs without previous prototype. */
|
||||
|
||||
int warn_strict_prototypes;
|
||||
|
||||
/* Nonzero means warn for any function def without prototype decl. */
|
||||
|
||||
int warn_missing_prototypes;
|
||||
@ -439,7 +432,7 @@ lang_decode_option (p)
|
||||
char *p;
|
||||
{
|
||||
if (!strcmp (p, "-ftraditional") || !strcmp (p, "-traditional"))
|
||||
flag_traditional = 1, dollars_in_ident = 1, flag_writable_strings = 1,
|
||||
dollars_in_ident = 1, flag_writable_strings = 1,
|
||||
flag_this_is_variable = 1, flag_new_for_scope = 0;
|
||||
/* The +e options are for cfront compatibility. They come in as
|
||||
`-+eN', to kludge around gcc.c's argument handling. */
|
||||
@ -536,14 +529,10 @@ lang_decode_option (p)
|
||||
warn_write_strings = setting;
|
||||
else if (!strcmp (p, "cast-qual"))
|
||||
warn_cast_qual = setting;
|
||||
else if (!strcmp (p, "traditional"))
|
||||
warn_traditional = setting;
|
||||
else if (!strcmp (p, "char-subscripts"))
|
||||
warn_char_subscripts = setting;
|
||||
else if (!strcmp (p, "pointer-arith"))
|
||||
warn_pointer_arith = setting;
|
||||
else if (!strcmp (p, "strict-prototypes"))
|
||||
warn_strict_prototypes = setting;
|
||||
else if (!strcmp (p, "missing-prototypes"))
|
||||
warn_missing_prototypes = setting;
|
||||
else if (!strcmp (p, "redundant-decls"))
|
||||
@ -1149,8 +1138,7 @@ delete_sanity (exp, size, doing_vec, use_global_delete)
|
||||
{
|
||||
case 2:
|
||||
maxindex = build_binary_op (MINUS_EXPR, size, integer_one_node, 1);
|
||||
if (! flag_traditional)
|
||||
pedwarn ("anachronistic use of array size in vector delete");
|
||||
pedwarn ("anachronistic use of array size in vector delete");
|
||||
/* Fall through. */
|
||||
case 1:
|
||||
break;
|
||||
@ -2777,6 +2765,13 @@ finish_file ()
|
||||
{
|
||||
tree decl = TREE_VALUE (vars);
|
||||
|
||||
#ifdef DWARF_DEBUGGING_INFO
|
||||
/* Output DWARF information for file-scope tentative data object
|
||||
declarations. */
|
||||
|
||||
if (write_symbols == DWARF_DEBUG)
|
||||
TIMEVAR (symout_time, dwarfout_file_scope_decl (decl, 1));
|
||||
#endif
|
||||
if (DECL_TEMPLATE_INSTANTIATION (decl)
|
||||
&& ! DECL_IN_AGGR_P (decl))
|
||||
{
|
||||
|
||||
@ -67,7 +67,6 @@ not_eq, EQCOMPARE, NORID,
|
||||
operator, OPERATOR, NORID,
|
||||
or, OROR, NORID,
|
||||
or_eq, ASSIGN, NORID,
|
||||
overload, OVERLOAD, NORID,
|
||||
private, VISSPEC, RID_PRIVATE,
|
||||
protected, VISSPEC, RID_PROTECTED,
|
||||
public, VISSPEC, RID_PUBLIC,
|
||||
|
||||
230
gcc/cp/hash.h
230
gcc/cp/hash.h
@ -3,12 +3,12 @@
|
||||
/* Command-line: gperf -p -j1 -g -o -t -N is_reserved_word -k1,4,$,7 gplus.gperf */
|
||||
struct resword { char *name; short token; enum rid rid;};
|
||||
|
||||
#define TOTAL_KEYWORDS 98
|
||||
#define TOTAL_KEYWORDS 97
|
||||
#define MIN_WORD_LENGTH 2
|
||||
#define MAX_WORD_LENGTH 16
|
||||
#define MIN_HASH_VALUE 4
|
||||
#define MAX_HASH_VALUE 258
|
||||
/* maximum key range = 255, duplicates = 0 */
|
||||
#define MAX_HASH_VALUE 202
|
||||
/* maximum key range = 199, duplicates = 0 */
|
||||
|
||||
#ifdef __GNUC__
|
||||
inline
|
||||
@ -18,21 +18,21 @@ hash (str, len)
|
||||
register char *str;
|
||||
register int unsigned len;
|
||||
{
|
||||
static unsigned short asso_values[] =
|
||||
static unsigned char asso_values[] =
|
||||
{
|
||||
259, 259, 259, 259, 259, 259, 259, 259, 259, 259,
|
||||
259, 259, 259, 259, 259, 259, 259, 259, 259, 259,
|
||||
259, 259, 259, 259, 259, 259, 259, 259, 259, 259,
|
||||
259, 259, 259, 259, 259, 259, 259, 259, 259, 259,
|
||||
259, 259, 259, 259, 259, 259, 259, 259, 259, 259,
|
||||
259, 259, 259, 259, 259, 259, 259, 259, 259, 259,
|
||||
259, 259, 259, 259, 259, 259, 259, 259, 259, 259,
|
||||
259, 259, 259, 259, 259, 259, 259, 259, 259, 259,
|
||||
259, 259, 259, 259, 259, 259, 259, 259, 259, 259,
|
||||
259, 259, 259, 259, 259, 0, 259, 27, 17, 20,
|
||||
40, 0, 64, 6, 10, 89, 259, 2, 110, 44,
|
||||
13, 107, 40, 10, 18, 55, 1, 3, 5, 17,
|
||||
2, 4, 259, 259, 259, 259, 259, 259,
|
||||
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
||||
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
||||
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
||||
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
||||
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
||||
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
||||
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
||||
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
||||
203, 203, 203, 203, 203, 203, 203, 203, 203, 203,
|
||||
203, 203, 203, 203, 203, 0, 203, 29, 22, 32,
|
||||
35, 0, 73, 8, 19, 48, 203, 0, 7, 15,
|
||||
11, 66, 9, 11, 19, 58, 1, 7, 83, 21,
|
||||
89, 5, 203, 203, 203, 203, 203, 203,
|
||||
};
|
||||
register int hval = len;
|
||||
|
||||
@ -67,150 +67,132 @@ is_reserved_word (str, len)
|
||||
{"",}, {"",}, {"",}, {"",},
|
||||
{"else", ELSE, NORID,},
|
||||
{"true", CXX_TRUE, NORID,},
|
||||
{"",}, {"",},
|
||||
{"",}, {"",}, {"",},
|
||||
{"try", TRY, NORID,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"not", '!', NORID,},
|
||||
{"xor_eq", ASSIGN, NORID,},
|
||||
{"extern", SCSPEC, RID_EXTERN,},
|
||||
{"",}, {"",}, {"",},
|
||||
{"xor", '^', NORID,},
|
||||
{"case", CASE, NORID,},
|
||||
{"",}, {"",},
|
||||
{"using", USING, NORID,},
|
||||
{"__extension__", EXTENSION, NORID},
|
||||
{"not_eq", EQCOMPARE, NORID,},
|
||||
{"",}, {"",},
|
||||
{"continue", CONTINUE, NORID,},
|
||||
{"new", NEW, NORID,},
|
||||
{"__inline", SCSPEC, RID_INLINE},
|
||||
{"",},
|
||||
{"__inline__", SCSPEC, RID_INLINE},
|
||||
{"extern", SCSPEC, RID_EXTERN,},
|
||||
{"",},
|
||||
{"template", TEMPLATE, RID_TEMPLATE,},
|
||||
{"__null", CONSTANT, RID_NULL},
|
||||
{"",}, {"",}, {"",},
|
||||
{"return", RETURN, NORID,},
|
||||
{"",}, {"",},
|
||||
{"and_eq", ASSIGN, NORID,},
|
||||
{"typename", TYPENAME_KEYWORD, NORID,},
|
||||
{"",}, {"",},
|
||||
{"long", TYPESPEC, RID_LONG,},
|
||||
{"not_eq", EQCOMPARE, NORID,},
|
||||
{"__alignof__", ALIGNOF, NORID},
|
||||
{"__inline", SCSPEC, RID_INLINE},
|
||||
{"using", USING, NORID,},
|
||||
{"__inline__", SCSPEC, RID_INLINE},
|
||||
{"while", WHILE, NORID,},
|
||||
{"enum", ENUM, NORID,},
|
||||
{"new", NEW, NORID,},
|
||||
{"case", CASE, NORID,},
|
||||
{"",}, {"",}, {"",},
|
||||
{"bool", TYPESPEC, RID_BOOL,},
|
||||
{"delete", DELETE, NORID,},
|
||||
{"typeid", TYPEID, NORID,},
|
||||
{"__wchar_t", TYPESPEC, RID_WCHAR /* Unique to ANSI C++ */,},
|
||||
{"namespace", NAMESPACE, NORID,},
|
||||
{"template", TEMPLATE, RID_TEMPLATE,},
|
||||
{"break", BREAK, NORID,},
|
||||
{"private", VISSPEC, RID_PRIVATE,},
|
||||
{"typename", TYPENAME_KEYWORD, NORID,},
|
||||
{"",},
|
||||
{"catch", CATCH, NORID,},
|
||||
{"",}, {"",}, {"",}, {"",},
|
||||
{"char", TYPESPEC, RID_CHAR,},
|
||||
{"",},
|
||||
{"__asm__", GCC_ASM_KEYWORD, NORID},
|
||||
{"double", TYPESPEC, RID_DOUBLE,},
|
||||
{"",},
|
||||
{"struct", AGGR, RID_RECORD,},
|
||||
{"reinterpret_cast", REINTERPRET_CAST, NORID,},
|
||||
{"",},
|
||||
{"static_cast", STATIC_CAST, NORID,},
|
||||
{"",},
|
||||
{"and", ANDAND, NORID,},
|
||||
{"typeof", TYPEOF, NORID,},
|
||||
{"switch", SWITCH, NORID,},
|
||||
{"return", RETURN, NORID,},
|
||||
{"",},
|
||||
{"__label__", LABEL, NORID},
|
||||
{"and_eq", ASSIGN, NORID,},
|
||||
{"asm", ASM_KEYWORD, NORID,},
|
||||
{"",},
|
||||
{"default", DEFAULT, NORID,},
|
||||
{"continue", CONTINUE, NORID,},
|
||||
{"namespace", NAMESPACE, NORID,},
|
||||
{"",},
|
||||
{"mutable", SCSPEC, RID_MUTABLE,},
|
||||
{"short", TYPESPEC, RID_SHORT,},
|
||||
{"signature", AGGR, RID_SIGNATURE /* Extension */,},
|
||||
{"const", CV_QUALIFIER, RID_CONST,},
|
||||
{"static", SCSPEC, RID_STATIC,},
|
||||
{"",}, {"",},
|
||||
{"for", FOR, NORID,},
|
||||
{"",}, {"",}, {"",},
|
||||
{"void", TYPESPEC, RID_VOID,},
|
||||
{"bitand", '&', NORID,},
|
||||
{"protected", VISSPEC, RID_PROTECTED,},
|
||||
{"enum", ENUM, NORID,},
|
||||
{"int", TYPESPEC, RID_INT,},
|
||||
{"",}, {"",}, {"",},
|
||||
{"float", TYPESPEC, RID_FLOAT,},
|
||||
{"compl", '~', NORID,},
|
||||
{"public", VISSPEC, RID_PUBLIC,},
|
||||
{"protected", VISSPEC, RID_PROTECTED,},
|
||||
{"break", BREAK, NORID,},
|
||||
{"",},
|
||||
{"__signed__", TYPESPEC, RID_SIGNED},
|
||||
{"dynamic_cast", DYNAMIC_CAST, NORID,},
|
||||
{"",},
|
||||
{"__attribute", ATTRIBUTE, NORID},
|
||||
{"",},
|
||||
{"__wchar_t", TYPESPEC, RID_WCHAR /* Unique to ANSI C++ */,},
|
||||
{"__attribute__", ATTRIBUTE, NORID},
|
||||
{"__asm", GCC_ASM_KEYWORD, NORID},
|
||||
{"",},
|
||||
{"const_cast", CONST_CAST, NORID,},
|
||||
{"double", TYPESPEC, RID_DOUBLE,},
|
||||
{"explicit", SCSPEC, RID_EXPLICIT,},
|
||||
{"__asm__", GCC_ASM_KEYWORD, NORID},
|
||||
{"reinterpret_cast", REINTERPRET_CAST, NORID,},
|
||||
{"and", ANDAND, NORID,},
|
||||
{"",}, {"",}, {"",},
|
||||
{"friend", SCSPEC, RID_FRIEND,},
|
||||
{"",}, {"",}, {"",},
|
||||
{"signed", TYPESPEC, RID_SIGNED,},
|
||||
{"this", THIS, NORID,},
|
||||
{"static_cast", STATIC_CAST, NORID,},
|
||||
{"struct", AGGR, RID_RECORD,},
|
||||
{"default", DEFAULT, NORID,},
|
||||
{"char", TYPESPEC, RID_CHAR,},
|
||||
{"__const", CV_QUALIFIER, RID_CONST},
|
||||
{"__const__", CV_QUALIFIER, RID_CONST},
|
||||
{"__volatile", CV_QUALIFIER, RID_VOLATILE},
|
||||
{"__null", CONSTANT, RID_NULL},
|
||||
{"__asm", GCC_ASM_KEYWORD, NORID},
|
||||
{"__volatile__", CV_QUALIFIER, RID_VOLATILE},
|
||||
{"typeof", TYPEOF, NORID,},
|
||||
{"__typeof__", TYPEOF, NORID},
|
||||
{"or_eq", ASSIGN, NORID,},
|
||||
{"short", TYPESPEC, RID_SHORT,},
|
||||
{"switch", SWITCH, NORID,},
|
||||
{"signature", AGGR, RID_SIGNATURE /* Extension */,},
|
||||
{"",},
|
||||
{"false", CXX_FALSE, NORID,},
|
||||
{"sizeof", SIZEOF, NORID,},
|
||||
{"long", TYPESPEC, RID_LONG,},
|
||||
{"or", OROR, NORID,},
|
||||
{"catch", CATCH, NORID,},
|
||||
{"union", AGGR, RID_UNION,},
|
||||
{"__signature__", AGGR, RID_SIGNATURE /* Extension */,},
|
||||
{"throw", THROW, NORID,},
|
||||
{"",},
|
||||
{"while", WHILE, NORID,},
|
||||
{"register", SCSPEC, RID_REGISTER,},
|
||||
{"__alignof__", ALIGNOF, NORID},
|
||||
{"class", AGGR, RID_CLASS,},
|
||||
{"typedef", SCSPEC, RID_TYPEDEF,},
|
||||
{"__signed", TYPESPEC, RID_SIGNED},
|
||||
{"",}, {"",},
|
||||
{"bitand", '&', NORID,},
|
||||
{"throw", THROW, NORID,},
|
||||
{"register", SCSPEC, RID_REGISTER,},
|
||||
{"for", FOR, NORID,},
|
||||
{"const", CV_QUALIFIER, RID_CONST,},
|
||||
{"static", SCSPEC, RID_STATIC,},
|
||||
{"unsigned", TYPESPEC, RID_UNSIGNED,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"__label__", LABEL, NORID},
|
||||
{"bitor", '|', NORID,},
|
||||
{"",},
|
||||
{"do", DO, NORID,},
|
||||
{"volatile", CV_QUALIFIER, RID_VOLATILE,},
|
||||
{"",}, {"",}, {"",}, {"",},
|
||||
{"if", IF, NORID,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"__sigof__", SIGOF, NORID /* Extension */,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"",}, {"",}, {"",},
|
||||
{"compl", '~', NORID,},
|
||||
{"public", VISSPEC, RID_PUBLIC,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"__typeof", TYPEOF, NORID},
|
||||
{"inline", SCSPEC, RID_INLINE,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"",}, {"",},
|
||||
{"private", VISSPEC, RID_PRIVATE,},
|
||||
{"__alignof", ALIGNOF, NORID},
|
||||
{"",}, {"",}, {"",},
|
||||
{"overload", OVERLOAD, NORID,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"explicit", SCSPEC, RID_EXPLICIT,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"goto", GOTO, NORID,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"sigof", SIGOF, NORID /* Extension */,},
|
||||
{"",},
|
||||
{"inline", SCSPEC, RID_INLINE,},
|
||||
{"do", DO, NORID,},
|
||||
{"",},
|
||||
{"virtual", SCSPEC, RID_VIRTUAL,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"bool", TYPESPEC, RID_BOOL,},
|
||||
{"xor_eq", ASSIGN, NORID,},
|
||||
{"",},
|
||||
{"float", TYPESPEC, RID_FLOAT,},
|
||||
{"dynamic_cast", DYNAMIC_CAST, NORID,},
|
||||
{"signed", TYPESPEC, RID_SIGNED,},
|
||||
{"xor", '^', NORID,},
|
||||
{"bitor", '|', NORID,},
|
||||
{"__extension__", EXTENSION, NORID},
|
||||
{"friend", SCSPEC, RID_FRIEND,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"this", THIS, NORID,},
|
||||
{"",},
|
||||
{"if", IF, NORID,},
|
||||
{"",}, {"",}, {"",},
|
||||
{"volatile", CV_QUALIFIER, RID_VOLATILE,},
|
||||
{"",}, {"",},
|
||||
{"__sigof__", SIGOF, NORID /* Extension */,},
|
||||
{"",}, {"",},
|
||||
{"const_cast", CONST_CAST, NORID,},
|
||||
{"",}, {"",},
|
||||
{"false", CXX_FALSE, NORID,},
|
||||
{"sizeof", SIZEOF, NORID,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"goto", GOTO, NORID,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"__typeof", TYPEOF, NORID},
|
||||
{"class", AGGR, RID_CLASS,},
|
||||
{"typedef", SCSPEC, RID_TYPEDEF,},
|
||||
{"",}, {"",},
|
||||
{"void", TYPESPEC, RID_VOID,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"auto", SCSPEC, RID_AUTO,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"",}, {"",}, {"",},
|
||||
{"operator", OPERATOR, NORID,},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"",}, {"",}, {"",}, {"",}, {"",},
|
||||
{"sigof", SIGOF, NORID /* Extension */,},
|
||||
};
|
||||
|
||||
if (len <= MAX_WORD_LENGTH && len >= MIN_WORD_LENGTH)
|
||||
|
||||
47
gcc/cp/lex.c
47
gcc/cp/lex.c
@ -821,8 +821,6 @@ init_lex ()
|
||||
UNSET_RESERVED_WORD ("xor");
|
||||
UNSET_RESERVED_WORD ("xor_eq");
|
||||
}
|
||||
if (! flag_traditional)
|
||||
UNSET_RESERVED_WORD ("overload");
|
||||
|
||||
token_count = init_parse ();
|
||||
interface_unknown = 1;
|
||||
@ -2339,12 +2337,6 @@ readescape (ignore_ptr)
|
||||
switch (c)
|
||||
{
|
||||
case 'x':
|
||||
if (warn_traditional)
|
||||
warning ("the meaning of `\\x' varies with -traditional");
|
||||
|
||||
if (flag_traditional)
|
||||
return c;
|
||||
|
||||
code = 0;
|
||||
count = 0;
|
||||
nonnull = 0;
|
||||
@ -2419,11 +2411,6 @@ readescape (ignore_ptr)
|
||||
return TARGET_BS;
|
||||
|
||||
case 'a':
|
||||
if (warn_traditional)
|
||||
warning ("the meaning of `\\a' varies with -traditional");
|
||||
|
||||
if (flag_traditional)
|
||||
return c;
|
||||
return TARGET_BELL;
|
||||
|
||||
case 'v':
|
||||
@ -3527,7 +3514,6 @@ real_yylex ()
|
||||
TREE_TYPE (yylval.ttype) = long_long_unsigned_type_node;
|
||||
|
||||
if (!spec_long && !spec_unsigned
|
||||
&& !(flag_traditional && base != 10)
|
||||
&& int_fits_type_p (yylval.ttype, integer_type_node))
|
||||
{
|
||||
type = integer_type_node;
|
||||
@ -3546,12 +3532,7 @@ real_yylex ()
|
||||
else if (! spec_long_long
|
||||
&& int_fits_type_p (yylval.ttype,
|
||||
long_unsigned_type_node))
|
||||
{
|
||||
if (flag_traditional && !spec_unsigned)
|
||||
type = long_integer_type_node;
|
||||
else
|
||||
type = long_unsigned_type_node;
|
||||
}
|
||||
type = long_unsigned_type_node;
|
||||
|
||||
else if (! spec_unsigned
|
||||
/* Verify value does not overflow into sign bit. */
|
||||
@ -3562,12 +3543,7 @@ real_yylex ()
|
||||
|
||||
else if (int_fits_type_p (yylval.ttype,
|
||||
long_long_unsigned_type_node))
|
||||
{
|
||||
if (flag_traditional && !spec_unsigned)
|
||||
type = long_long_integer_type_node;
|
||||
else
|
||||
type = long_long_unsigned_type_node;
|
||||
}
|
||||
type = long_long_unsigned_type_node;
|
||||
|
||||
else
|
||||
{
|
||||
@ -3667,7 +3643,7 @@ real_yylex ()
|
||||
num_chars = max_chars;
|
||||
error ("character constant too long");
|
||||
}
|
||||
else if (num_chars != 1 && ! flag_traditional)
|
||||
else if (num_chars != 1)
|
||||
warning ("multi-character character constant");
|
||||
|
||||
/* If char type is signed, sign-extend the constant. */
|
||||
@ -4094,22 +4070,7 @@ build_lang_decl (code, name, type)
|
||||
== TREE_PERMANENT (t), 234);
|
||||
DECL_MAIN_VARIANT (t) = t;
|
||||
if (current_lang_name == lang_name_cplusplus)
|
||||
{
|
||||
DECL_LANGUAGE (t) = lang_cplusplus;
|
||||
#if 0
|
||||
#ifndef NO_AUTO_OVERLOAD
|
||||
if (code == FUNCTION_DECL && name != 0
|
||||
&& ! (IDENTIFIER_LENGTH (name) == 4
|
||||
&& IDENTIFIER_POINTER (name)[0] == 'm'
|
||||
&& strcmp (IDENTIFIER_POINTER (name), "main") == 0)
|
||||
&& ! (IDENTIFIER_LENGTH (name) > 10
|
||||
&& IDENTIFIER_POINTER (name)[0] == '_'
|
||||
&& IDENTIFIER_POINTER (name)[1] == '_'
|
||||
&& strncmp (IDENTIFIER_POINTER (name)+2, "builtin_", 8) == 0))
|
||||
TREE_OVERLOADED (name) = 1;
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
DECL_LANGUAGE (t) = lang_cplusplus;
|
||||
else if (current_lang_name == lang_name_c)
|
||||
DECL_LANGUAGE (t) = lang_c;
|
||||
else my_friendly_abort (64);
|
||||
|
||||
@ -62,10 +62,6 @@ static char *scratch_firstobj;
|
||||
# define OB_FINISH() (obstack_1grow (&scratch_obstack, '\0'))
|
||||
# define OB_LAST() (obstack_next_free (&scratch_obstack)[-1])
|
||||
|
||||
#ifdef NO_AUTO_OVERLOAD
|
||||
int is_overloaded ();
|
||||
#endif
|
||||
|
||||
void
|
||||
init_method ()
|
||||
{
|
||||
@ -1108,56 +1104,6 @@ get_id_2 (name, name2)
|
||||
OB_FINISH ();
|
||||
return get_identifier (obstack_base (&scratch_obstack));
|
||||
}
|
||||
|
||||
/* Top-level interface to explicit overload requests. Allow NAME
|
||||
to be overloaded. Error if NAME is already declared for the current
|
||||
scope. Warning if function is redundantly overloaded. */
|
||||
|
||||
void
|
||||
declare_overloaded (name)
|
||||
tree name;
|
||||
{
|
||||
#ifdef NO_AUTO_OVERLOAD
|
||||
if (is_overloaded (name))
|
||||
warning ("function `%s' already declared overloaded",
|
||||
IDENTIFIER_POINTER (name));
|
||||
else if (IDENTIFIER_GLOBAL_VALUE (name))
|
||||
error ("overloading function `%s' that is already defined",
|
||||
IDENTIFIER_POINTER (name));
|
||||
else
|
||||
{
|
||||
TREE_OVERLOADED (name) = 1;
|
||||
IDENTIFIER_GLOBAL_VALUE (name) = build_tree_list (name, NULL_TREE);
|
||||
TREE_TYPE (IDENTIFIER_GLOBAL_VALUE (name)) = unknown_type_node;
|
||||
}
|
||||
#else
|
||||
if (current_lang_name == lang_name_cplusplus)
|
||||
{
|
||||
if (0)
|
||||
warning ("functions are implicitly overloaded in C++");
|
||||
}
|
||||
else if (current_lang_name == lang_name_c)
|
||||
error ("overloading function `%s' cannot be done in C language context");
|
||||
else
|
||||
my_friendly_abort (76);
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef NO_AUTO_OVERLOAD
|
||||
/* Check to see if NAME is overloaded. For first approximation,
|
||||
check to see if its TREE_OVERLOADED is set. This is used on
|
||||
IDENTIFIER nodes. */
|
||||
|
||||
int
|
||||
is_overloaded (name)
|
||||
tree name;
|
||||
{
|
||||
/* @@ */
|
||||
return (TREE_OVERLOADED (name)
|
||||
&& (! IDENTIFIER_CLASS_VALUE (name) || current_class_type == 0)
|
||||
&& ! IDENTIFIER_LOCAL_VALUE (name));
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Given a tree_code CODE, and some arguments (at least one),
|
||||
attempt to use an overloaded operator on the arguments.
|
||||
@ -1428,9 +1374,8 @@ build_opfncall (code, flags, xarg1, xarg2, arg3)
|
||||
|
||||
/* There's probably a LOT of code in the world that
|
||||
relies upon this old behavior. */
|
||||
if (! flag_traditional)
|
||||
pedwarn ("no `operator%s (int)' declared for postfix `%s', using prefix operator instead",
|
||||
op, op);
|
||||
pedwarn ("no `operator%s (int)' declared for postfix `%s', using prefix operator instead",
|
||||
op, op);
|
||||
xarg2 = NULL_TREE;
|
||||
binary_is_unary = 1;
|
||||
}
|
||||
|
||||
@ -144,7 +144,7 @@ empty_parms ()
|
||||
/* the reserved words... C++ extensions */
|
||||
%token <ttype> AGGR
|
||||
%token <ttype> VISSPEC
|
||||
%token DELETE NEW OVERLOAD THIS OPERATOR CXX_TRUE CXX_FALSE
|
||||
%token DELETE NEW THIS OPERATOR CXX_TRUE CXX_FALSE
|
||||
%token NAMESPACE TYPENAME_KEYWORD USING
|
||||
%token LEFT_RIGHT TEMPLATE
|
||||
%token TYPEID DYNAMIC_CAST STATIC_CAST REINTERPRET_CAST CONST_CAST
|
||||
@ -359,7 +359,6 @@ extdef:
|
||||
{ if (pending_inlines) do_pending_inlines (); }
|
||||
| template_def
|
||||
{ if (pending_inlines) do_pending_inlines (); }
|
||||
| overloaddef
|
||||
| asm_keyword '(' string ')' ';'
|
||||
{ if (TREE_CHAIN ($3)) $3 = combine_strings ($3);
|
||||
assemble_asm ($3); }
|
||||
@ -469,18 +468,6 @@ template_parm:
|
||||
{ $$ = build_tree_list ($3, $1.t); }
|
||||
;
|
||||
|
||||
overloaddef:
|
||||
OVERLOAD ov_identifiers ';'
|
||||
{ warning ("use of `overload' is an anachronism"); }
|
||||
;
|
||||
|
||||
ov_identifiers:
|
||||
IDENTIFIER
|
||||
{ declare_overloaded ($1); }
|
||||
| ov_identifiers ',' IDENTIFIER
|
||||
{ declare_overloaded ($3); }
|
||||
;
|
||||
|
||||
template_def:
|
||||
template_header
|
||||
extdef
|
||||
@ -764,13 +751,13 @@ member_init_list:
|
||||
member_init:
|
||||
'(' nonnull_exprlist ')'
|
||||
{
|
||||
if (current_class_name && !flag_traditional)
|
||||
if (current_class_name)
|
||||
pedwarn ("anachronistic old style base class initializer");
|
||||
expand_member_init (current_class_ref, NULL_TREE, $2);
|
||||
}
|
||||
| LEFT_RIGHT
|
||||
{
|
||||
if (current_class_name && !flag_traditional)
|
||||
if (current_class_name)
|
||||
pedwarn ("anachronistic old style base class initializer");
|
||||
expand_member_init (current_class_ref, NULL_TREE, void_type_node);
|
||||
}
|
||||
|
||||
@ -1434,7 +1434,11 @@ tsubst (t, args, nargs, in_decl)
|
||||
|
||||
if (type == TREE_TYPE (t)
|
||||
&& (! member || ctx == DECL_CLASS_CONTEXT (t)))
|
||||
return t;
|
||||
{
|
||||
t = copy_node (t);
|
||||
copy_lang_decl (t);
|
||||
return t;
|
||||
}
|
||||
|
||||
/* Do we already have this instantiation? */
|
||||
if (DECL_TEMPLATE_INFO (t) != NULL_TREE)
|
||||
|
||||
@ -1573,9 +1573,6 @@ default_conversion (exp)
|
||||
if (t != type)
|
||||
return convert (t, exp);
|
||||
}
|
||||
if (flag_traditional
|
||||
&& TYPE_MAIN_VARIANT (type) == float_type_node)
|
||||
return convert (double_type_node, exp);
|
||||
|
||||
return exp;
|
||||
}
|
||||
@ -3474,18 +3471,12 @@ build_binary_op_nodefault (code, orig_op0, orig_op1, error_code)
|
||||
else if (code0 == POINTER_TYPE && code1 == INTEGER_TYPE)
|
||||
{
|
||||
result_type = type0;
|
||||
if (pedantic)
|
||||
pedwarn ("ANSI C++ forbids comparison between pointer and integer");
|
||||
else if (! flag_traditional)
|
||||
warning ("comparison between pointer and integer");
|
||||
pedwarn ("ANSI C++ forbids comparison between pointer and integer");
|
||||
}
|
||||
else if (code0 == INTEGER_TYPE && code1 == POINTER_TYPE)
|
||||
{
|
||||
result_type = type1;
|
||||
if (pedantic)
|
||||
pedwarn ("ANSI C++ forbids comparison between pointer and integer");
|
||||
else if (! flag_traditional)
|
||||
warning ("comparison between pointer and integer");
|
||||
pedwarn ("ANSI C++ forbids comparison between pointer and integer");
|
||||
}
|
||||
break;
|
||||
}
|
||||
@ -4493,7 +4484,6 @@ unary_complex_lvalue (code, arg)
|
||||
is really the representation of a pointer to it.
|
||||
Here give the representation its true type. */
|
||||
tree t;
|
||||
tree offset;
|
||||
|
||||
my_friendly_assert (TREE_CODE (arg) != SCOPE_REF, 313);
|
||||
|
||||
@ -4508,6 +4498,9 @@ unary_complex_lvalue (code, arg)
|
||||
return build_unary_op (ADDR_EXPR, t, 0);
|
||||
else
|
||||
{
|
||||
tree type;
|
||||
tree offset = integer_zero_node;
|
||||
|
||||
if (TREE_OPERAND (arg, 0)
|
||||
&& (TREE_CODE (TREE_OPERAND (arg, 0)) != NOP_EXPR
|
||||
|| TREE_OPERAND (TREE_OPERAND (arg, 0), 0) != error_mark_node))
|
||||
@ -4519,10 +4512,23 @@ unary_complex_lvalue (code, arg)
|
||||
return error_mark_node;
|
||||
}
|
||||
|
||||
/* Add in the offset to the right subobject. */
|
||||
offset = get_delta_difference (DECL_FIELD_CONTEXT (t),
|
||||
TREE_TYPE (TREE_OPERAND (arg, 0)),
|
||||
0);
|
||||
type = TREE_TYPE (TREE_OPERAND (arg, 0));
|
||||
|
||||
if (TREE_CODE (TREE_TYPE (arg)) == OFFSET_TYPE)
|
||||
{
|
||||
/* Add in the offset to the intermediate subobject, if any. */
|
||||
offset = get_delta_difference (TYPE_OFFSET_BASETYPE (TREE_TYPE (arg)),
|
||||
type,
|
||||
0);
|
||||
type = TYPE_OFFSET_BASETYPE (TREE_TYPE (arg));
|
||||
}
|
||||
|
||||
/* Now in the offset to the final subobject. */
|
||||
offset = size_binop (PLUS_EXPR,
|
||||
offset,
|
||||
get_delta_difference (DECL_FIELD_CONTEXT (t),
|
||||
type,
|
||||
0));
|
||||
|
||||
/* Add in the offset to the field. */
|
||||
offset = size_binop (PLUS_EXPR, offset,
|
||||
@ -6063,13 +6069,13 @@ get_delta_difference (from, to, force)
|
||||
if (!force)
|
||||
{
|
||||
error_not_base_type (from, to);
|
||||
error (" in pointer to member function conversion");
|
||||
error (" in pointer to member conversion");
|
||||
return delta;
|
||||
}
|
||||
binfo = get_binfo (to, from, 1);
|
||||
if (binfo == error_mark_node)
|
||||
{
|
||||
error (" in pointer to member function conversion");
|
||||
error (" in pointer to member conversion");
|
||||
return delta;
|
||||
}
|
||||
if (binfo == 0)
|
||||
@ -6546,31 +6552,6 @@ convert_for_assignment (type, rhs, errtype, fndecl, parmnum)
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (TREE_CODE (ttr) == OFFSET_TYPE
|
||||
&& TREE_CODE (ttl) != OFFSET_TYPE)
|
||||
{
|
||||
/* Normally, pointers to different type codes (other
|
||||
than void) are not compatible, but we perform
|
||||
some type instantiation if that resolves the
|
||||
ambiguity of (X Y::*) and (X *). */
|
||||
|
||||
if (current_class_ptr)
|
||||
{
|
||||
if (TREE_CODE (rhs) == INTEGER_CST)
|
||||
{
|
||||
rhs = build (PLUS_EXPR, build_pointer_type (TREE_TYPE (ttr)),
|
||||
current_class_ptr, rhs);
|
||||
return convert_for_assignment (type, rhs,
|
||||
errtype, fndecl, parmnum);
|
||||
}
|
||||
}
|
||||
if (TREE_CODE (ttl) == METHOD_TYPE)
|
||||
error ("%s between pointer-to-method and pointer-to-member types",
|
||||
errtype);
|
||||
else
|
||||
error ("%s between pointer and pointer-to-member types", errtype);
|
||||
return error_mark_node;
|
||||
}
|
||||
else
|
||||
{
|
||||
int add_quals = 0, const_parity = 0, volatile_parity = 0;
|
||||
|
||||
@ -879,12 +879,7 @@ digest_init (type, init, tail)
|
||||
*tail = old_tail_contents;
|
||||
return process_init_constructor (type, 0, tail);
|
||||
}
|
||||
else if (flag_traditional)
|
||||
/* Traditionally one can say `char x[100] = 0;'. */
|
||||
return process_init_constructor (type,
|
||||
build_nt (CONSTRUCTOR, NULL_TREE,
|
||||
tree_cons (NULL_TREE, init, NULL_TREE)),
|
||||
(tree*)0);
|
||||
|
||||
if (code != ARRAY_TYPE)
|
||||
return convert_for_initialization (NULL_TREE, type, init, LOOKUP_NORMAL,
|
||||
"initialization", NULL_TREE, 0);
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user