+2003-04-03 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
+
+ * gengtype-lex.l (IWORD): Add CHAR_BITFIELD.
+ * system.h (CHAR_BITFIELD): New.
+
2003-04-03 Kazu Hirata <kazu@cs.umass.edu>
* config/h8300/h8300.md (a peephole2): Generalize to accept GT
+2003-04-03 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
+
+ * operators.def (DEF_SIMPLE_OPERATOR, DEF_ASSN_OPERATOR,
+ DEF_ASSN_OPERATOR): Delete spurious semi-colon.
+ * rtti.c (dfs_class_hint_mark): Likewise.
+
+ * decl.c (push_local_name, push_class_level_binding,
+ maybe_inject_for_scope_var): Don't use POP_TIMEVAR_AND_RETURN in
+ functions returning void.
+ * decl2.c (add_using_namespace): Likewise.
+
+ * decl.c (print_binding_level, print_other_binding_stack,
+ print_binding_stack): Cast argument of %p specifier to void*.
+ * ptree.c (cxx_print_decl): Likewise.
+
+ * cp-tree.h (VAR_OR_FUNCTION_DECL_CHECK,
+ VAR_FUNCTION_OR_PARM_DECL_CHECK,
+ VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK, RECORD_OR_UNION_TYPE_CHECK,
+ BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK, LANG_TYPE_CLASS_CHECK,
+ LANG_TYPE_PTRMEM_CHECK, LANG_DECL_U2_CHECK): Add __extension__.
+
+ * decl.c (set_current_binding_level): New macro. Use throughout
+ when setting the current binding level.
+
+ * cp-tree.h (cp_lvalue_kind, base_access): Delete trailing comma
+ in enum.
+ * method.c (mangling_flags): Likewise.
+
+ * cp-tree.h (lang_type_header): Add __extension__ and use
+ CHAR_BITFIELD for members.
+
2003-04-02 Geoffrey Keating <geoffk@apple.com>
PR other/9274
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
-#define VAR_OR_FUNCTION_DECL_CHECK(NODE) \
+#define VAR_OR_FUNCTION_DECL_CHECK(NODE) __extension__ \
({ const tree __t = (NODE); \
enum tree_code const __c = TREE_CODE(__t); \
if (__c != VAR_DECL && __c != FUNCTION_DECL) \
__FUNCTION__); \
__t; })
-#define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) \
+#define VAR_FUNCTION_OR_PARM_DECL_CHECK(NODE) __extension__ \
({ const tree __t = (NODE); \
enum tree_code const __c = TREE_CODE(__t); \
if (__c != VAR_DECL \
__FUNCTION__); \
__t; })
-#define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) \
+#define VAR_TEMPL_TYPE_OR_FUNCTION_DECL_CHECK(NODE) __extension__ \
({ const tree __t = (NODE); \
enum tree_code const __c = TREE_CODE(__t); \
if (__c != VAR_DECL \
__FUNCTION__); \
__t; })
-#define RECORD_OR_UNION_TYPE_CHECK(NODE) \
+#define RECORD_OR_UNION_TYPE_CHECK(NODE) __extension__ \
({ const tree __t = (NODE); \
enum tree_code const __c = TREE_CODE(__t); \
if (__c != RECORD_TYPE && __c != UNION_TYPE) \
__FUNCTION__); \
__t; })
-#define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) \
+#define BOUND_TEMPLATE_TEMPLATE_PARM_TYPE_CHECK(NODE) __extension__ \
({ const tree __t = (NODE); \
enum tree_code const __c = TREE_CODE(__t); \
if (__c != BOUND_TEMPLATE_TEMPLATE_PARM) \
/* This is a few header flags for 'struct lang_type'. Actually,
all but the first are used only for lang_type_class; they
are put in this structure to save space. */
-struct lang_type_header GTY(())
+__extension__ struct lang_type_header GTY(())
{
- unsigned char is_lang_type_class : 1;
-
- unsigned char has_type_conversion : 1;
- unsigned char has_init_ref : 1;
- unsigned char has_default_ctor : 1;
- unsigned char uses_multiple_inheritance : 1;
- unsigned char const_needs_init : 1;
- unsigned char ref_needs_init : 1;
- unsigned char has_const_assign_ref : 1;
+ CHAR_BITFIELD is_lang_type_class : 1;
+
+ CHAR_BITFIELD has_type_conversion : 1;
+ CHAR_BITFIELD has_init_ref : 1;
+ CHAR_BITFIELD has_default_ctor : 1;
+ CHAR_BITFIELD uses_multiple_inheritance : 1;
+ CHAR_BITFIELD const_needs_init : 1;
+ CHAR_BITFIELD ref_needs_init : 1;
+ CHAR_BITFIELD has_const_assign_ref : 1;
};
/* This structure provides additional information above and beyond
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
-#define LANG_TYPE_CLASS_CHECK(NODE) \
+#define LANG_TYPE_CLASS_CHECK(NODE) __extension__ \
({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \
if (! lt->u.h.is_lang_type_class) \
lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
<->u.c; })
-#define LANG_TYPE_PTRMEM_CHECK(NODE) \
+#define LANG_TYPE_PTRMEM_CHECK(NODE) __extension__ \
({ struct lang_type *lt = TYPE_LANG_SPECIFIC (NODE); \
if (lt->u.h.is_lang_type_class) \
lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
#if defined ENABLE_TREE_CHECKING && (GCC_VERSION >= 2007)
-#define LANG_DECL_U2_CHECK(NODE, TF) \
+#define LANG_DECL_U2_CHECK(NODE, TF) __extension__ \
({ struct lang_decl *lt = DECL_LANG_SPECIFIC (NODE); \
if (lt->decl_flags.u2sel != TF) \
lang_check_failed (__FILE__, __LINE__, __FUNCTION__); \
clk_none = 0, /* Things that are not an lvalue. */
clk_ordinary = 1, /* An ordinary lvalue. */
clk_class = 2, /* An rvalue of class-type. */
- clk_bitfield = 4, /* An lvalue for a bit-field. */
+ clk_bitfield = 4 /* An lvalue for a bit-field. */
} cp_lvalue_kind;
/* The kinds of scopes we recognize. */
ba_check = 2, /* Check access */
ba_not_special = 3, /* Do not consider special privilege
current_class_type might give. */
- ba_quiet = 4, /* Do not issue error messages (bit mask). */
+ ba_quiet = 4 /* Do not issue error messages (bit mask). */
} base_access;
/* The kind of base we can find, looking in a class hierarchy.
? cp_function_chain->bindings \
: scope_chain->bindings)
+#define set_current_binding_level(bl) do { \
+ struct cp_binding_level * const bl_ = bl; \
+ if (cfun && cp_function_chain->bindings) \
+ cp_function_chain->bindings = bl_; \
+ else \
+ scope_chain->bindings = bl_; \
+ } while (0)
+
/* The binding level of the current class, if any. */
#define class_binding_level scope_chain->class_bindings
are active. */
memset ((char*) newlevel, 0, sizeof (struct cp_binding_level));
newlevel->level_chain = current_binding_level;
- current_binding_level = newlevel;
+ set_current_binding_level (newlevel);
newlevel->tag_transparent = tag_transparent;
newlevel->more_cleanups_ok = 1;
#endif /* defined(DEBUG_BINDING_LEVELS) */
{
register struct cp_binding_level *level = current_binding_level;
- current_binding_level = current_binding_level->level_chain;
+ set_current_binding_level (current_binding_level->level_chain);
level->level_chain = free_binding_level;
#if 0 /* defined(DEBUG_BINDING_LEVELS) */
if (level->binding_depth != binding_depth)
suspend_binding_level (void)
{
if (class_binding_level)
- current_binding_level = class_binding_level;
+ set_current_binding_level (class_binding_level);
if (global_binding_level)
{
}
is_class_level = 0;
#endif /* defined(DEBUG_BINDING_LEVELS) */
- current_binding_level = current_binding_level->level_chain;
+ set_current_binding_level (current_binding_level->level_chain);
find_class_binding_level ();
}
my_friendly_assert(!class_binding_level, 386);
/* Also, resuming a non-directly nested namespace is a no-no. */
my_friendly_assert(b->level_chain == current_binding_level, 386);
- current_binding_level = b;
+ set_current_binding_level (b);
#if defined(DEBUG_BINDING_LEVELS)
b->binding_depth = binding_depth;
indent ();
tree t;
int i = 0, len;
fprintf (stderr, " blocks=");
- fprintf (stderr, HOST_PTR_PRINTF, lvl->blocks);
+ fprintf (stderr, HOST_PTR_PRINTF, (void *) lvl->blocks);
if (lvl->tag_transparent)
fprintf (stderr, " tag-transparent");
if (lvl->more_cleanups_ok)
for (level = stack; level != global_binding_level; level = level->level_chain)
{
fprintf (stderr, "binding level ");
- fprintf (stderr, HOST_PTR_PRINTF, level);
+ fprintf (stderr, HOST_PTR_PRINTF, (void *) level);
fprintf (stderr, "\n");
print_binding_level (level);
}
{
struct cp_binding_level *b;
fprintf (stderr, "current_binding_level=");
- fprintf (stderr, HOST_PTR_PRINTF, current_binding_level);
+ fprintf (stderr, HOST_PTR_PRINTF, (void *) current_binding_level);
fprintf (stderr, "\nclass_binding_level=");
- fprintf (stderr, HOST_PTR_PRINTF, class_binding_level);
+ fprintf (stderr, HOST_PTR_PRINTF, (void *) class_binding_level);
fprintf (stderr, "\nglobal_binding_level=");
- fprintf (stderr, HOST_PTR_PRINTF, global_binding_level);
+ fprintf (stderr, HOST_PTR_PRINTF, (void *) global_binding_level);
fprintf (stderr, "\n");
if (class_binding_level)
{
DECL_DISCRIMINATOR (decl) = 1;
VARRAY_TREE (local_names, i) = decl;
- POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
+ timevar_pop (TV_NAME_LOOKUP);
+ return;
}
}
else
{
b = current_binding_level;
- current_binding_level = level;
+ set_current_binding_level (level);
x = pushdecl (x);
- current_binding_level = b;
+ set_current_binding_level (b);
}
current_function_decl = function_decl;
POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, x);
/* The class_binding_level will be NULL if x is a template
parameter name in a member template. */
if (!class_binding_level)
- POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
+ {
+ timevar_pop (TV_NAME_LOOKUP);
+ return;
+ }
/* Make sure that this new member does not have the same name
as a template parameter. */
INHERITED_VALUE_BINDING_P (binding) = 0;
TREE_TYPE (shadow) = x;
IDENTIFIER_CLASS_VALUE (name) = x;
- POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
+ timevar_pop (TV_NAME_LOOKUP);
+ return;
}
}
current_lang_name = lang_name_c;
current_function_decl = NULL_TREE;
- current_binding_level = NULL_BINDING_LEVEL;
+ set_current_binding_level (NULL_BINDING_LEVEL);
free_binding_level = NULL_BINDING_LEVEL;
build_common_tree_nodes (flag_signed_char);
{
timevar_push (TV_NAME_LOOKUP);
if (!DECL_NAME (decl))
- POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
+ {
+ timevar_pop (TV_NAME_LOOKUP);
+ return;
+ }
/* Declarations of __FUNCTION__ and its ilk appear magically when
the variable is first used. If that happens to be inside a
for-loop, we don't want to do anything special. */
if (DECL_PRETTY_FUNCTION_P (decl))
- POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
+ {
+ timevar_pop (TV_NAME_LOOKUP);
+ return;
+ }
if (current_binding_level->is_for_scope)
{
if (decl_context == NORMAL && !toplevel_bindings_p ())
{
struct cp_binding_level *b = current_binding_level;
- current_binding_level = b->level_chain;
+ set_current_binding_level (b->level_chain);
if (current_binding_level != 0 && toplevel_bindings_p ())
decl_context = PARM;
- current_binding_level = b;
+ set_current_binding_level (b);
}
if (name == NULL)
FIXME factor out the non-RTL stuff. */
bl = current_binding_level;
init_function_start (decl1, input_filename, lineno);
- current_binding_level = bl;
+ set_current_binding_level (bl);
/* Even though we're inside a function body, we still don't want to
call expand_expr to calculate the size of a variable-sized array.
timevar_push (TV_NAME_LOOKUP);
/* Using oneself is a no-op. */
if (user == used)
- POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
+ {
+ timevar_pop (TV_NAME_LOOKUP);
+ return;
+ }
my_friendly_assert (TREE_CODE (user) == NAMESPACE_DECL, 380);
my_friendly_assert (TREE_CODE (used) == NAMESPACE_DECL, 380);
/* Check if we already have this. */
if (!indirect)
/* Promote to direct usage. */
TREE_INDIRECT_USING (t) = 0;
- POP_TIMEVAR_AND_RETURN (TV_NAME_LOOKUP, (void)0);
+ timevar_pop (TV_NAME_LOOKUP);
+ return;
}
/* Add used to the user's using list. */
mf_maybe_uninstantiated = 1,
/* When mangling a numeric value, use the form `_XX_' (instead of
just `XX') if the value has more than one digit. */
- mf_use_underscores_around_value = 2,
+ mf_use_underscores_around_value = 2
};
typedef enum mangling_flags mangling_flags;
DEF_SIMPLE_OPERATOR ("<?", MIN_EXPR, "v23min", 2)
DEF_SIMPLE_OPERATOR (">?", MAX_EXPR, "v23max", 2)
/* This one is needed for mangling. */
-DEF_SIMPLE_OPERATOR ("::", SCOPE_REF, "sr", 2);
+DEF_SIMPLE_OPERATOR ("::", SCOPE_REF, "sr", 2)
/* Assignment operators. */
DEF_ASSN_OPERATOR ("=", NOP_EXPR, "aS", 2)
DEF_ASSN_OPERATOR ("<<=", LSHIFT_EXPR, "lS", 2)
DEF_ASSN_OPERATOR (">>=", RSHIFT_EXPR, "rS", 2)
/* These operators are GNU extensions. */
-DEF_ASSN_OPERATOR ("<?=", MIN_EXPR, "v23miN", 2);
-DEF_ASSN_OPERATOR (">?=", MAX_EXPR, "v23maX", 2);
+DEF_ASSN_OPERATOR ("<?=", MIN_EXPR, "v23miN", 2)
+DEF_ASSN_OPERATOR (">?=", MAX_EXPR, "v23maX", 2)
/* Ternary operators. */
DEF_SIMPLE_OPERATOR ("?:", COND_EXPR, "qu", 3)
&& DECL_PENDING_INLINE_INFO (node))
{
fprintf (file, " pending-inline-info ");
- fprintf (file, HOST_PTR_PRINTF, DECL_PENDING_INLINE_INFO (node));
+ fprintf (file, HOST_PTR_PRINTF, (void *) DECL_PENDING_INLINE_INFO (node));
}
if (TREE_CODE (node) == TYPE_DECL
&& DECL_SORTED_FIELDS (node))
{
fprintf (file, " sorted-fields ");
- fprintf (file, HOST_PTR_PRINTF, DECL_SORTED_FIELDS (node));
+ fprintf (file, HOST_PTR_PRINTF, (void *) DECL_SORTED_FIELDS (node));
}
if ((TREE_CODE (node) == FUNCTION_DECL || TREE_CODE (node) == VAR_DECL)
&& DECL_TEMPLATE_INFO (node))
{
fprintf (file, " template-info ");
- fprintf (file, HOST_PTR_PRINTF, DECL_TEMPLATE_INFO (node));
+ fprintf (file, HOST_PTR_PRINTF, (void *) DECL_TEMPLATE_INFO (node));
}
}
SET_CLASSTYPE_MARKED (basetype);
}
return NULL_TREE;
-};
+}
/* Clear the base's dfs marks, after searching for duplicate bases. */
ID [[:alpha:]_][[:alnum:]_]*
WS [[:space:]]+
-IWORD short|long|(un)?signed|char|int|HOST_WIDE_INT|bool|size_t
+IWORD short|long|(un)?signed|char|int|HOST_WIDE_INT|bool|size_t|CHAR_BITFIELD
ITYPE {IWORD}({WS}{IWORD})*
%x in_struct in_struct_comment in_comment in_yacc_escape
#define HOST_BIT_BUCKET "/dev/null"
#endif
-/* Be conservative and only use enum bitfields with GCC.
+/* Be conservative and only use enum bitfields with GCC. Likewise for
+ char bitfields.
FIXME: provide a complete autoconf test for buggy enum bitfields. */
#if (GCC_VERSION > 2000)
#define ENUM_BITFIELD(TYPE) enum TYPE
+#define CHAR_BITFIELD unsigned char
#else
#define ENUM_BITFIELD(TYPE) unsigned int
+#define CHAR_BITFIELD unsigned int
#endif
#ifndef offsetof
projects / thirdparty / gcc.git / commitdiff
