+Mon Sep 30 12:58:40 1996 Mike Stump <mrs@cygnus.com>
+
+ * input.c (sub_getch): Handle 8-bit characters in string literals.
+
+Sun Sep 29 03:12:01 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * tree.c (mapcar): Handle CONSTRUCTORs.
+ (copy_to_permanent): Handle expression_obstack properly.
+
+ * Make-lang.in (cplib2.txt): Also depend on the headers.
+
+ * rtti.c (get_tinfo_var): Don't assume that POINTER_SIZE ==
+ INT_TYPE_SIZE.
+ (expand_class_desc): Use USItype for offset field.
+ * tinfo.h (struct __class_type_info): Likewise.
+
+ * method.c (build_overload_int): TYPE_PRECISION should be applied
+ to types.
+
+Sat Sep 28 14:44:50 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * call.c (build_new_op): A COND_EXPR involving void must be a
+ builtin.
+
+Fri Sep 27 16:40:30 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * typeck.c (build_x_component_ref): New fn.
+ (build_object_ref): Use it.
+ * parse.y (primary): Use it.
+ * decl2.c (build_expr_from_tree): Use it.
+ * cp-tree.h: Declare it.
+
+ * decl.c (start_decl): variable-sized arrays cannot be initialized.
+ * error.c (dump_type_suffix): Handle variable arrays.
+
+Fri Sep 27 13:14:05 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * Make-lang.in (exception.o): Put back compiling it with -fPIC.
+
+Fri Sep 27 03:00:09 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * decl.c (lookup_name_real): Don't try to look up anything in a
+ TYPENAME_TYPE.
+
+ * tinfo2.cc (__throw_type_match_rtti): Oops.
+
+Thu Sep 26 22:11:05 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * Make-lang.in (exception.o): Use -fno-PIC for now.
+
+Thu Sep 26 10:59:00 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * rtti.c (build_dynamic_cast): Pass tinfo fns rather than
+ calling them.
+ (get_tinfo_fn_dynamic): Extracted from build_typeid.
+ * tinfo2.cc (__dynamic_cast): Adjust.
+
+ * rtti.c (build_typeid): Use resolves_to_fixed_type_p.
+ (build_x_typeid): Likewise.
+
+ * parse.y: Call build_x_typeid instead of build_typeid.
+ * cp-tree.def: Add TYPEID_EXPR.
+ * pt.c (tsubst_copy): Handle typeid.
+ * decl2.c (build_expr_from_tree): Likewise.
+ * rtti.c (build_x_typeid): Throw bad_typeid from here.
+ (build_typeid): Not here.
+ * cp-tree.h: Declare build_x_typeid.
+
+Wed Sep 25 17:26:16 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * call.c (convert_like): Pull out constant values.
+
+ * tree.c (mapcar): Use build_cplus_array_type, not build_array_type.
+
+Wed Sep 25 17:28:53 1996 Michael Meissner <meissner@tiktok.cygnus.com>
+
+ * decl.c (init_decl_processing): Create short int types before
+ creating size_t in case a machine description needs to use
+ unsigned short for size_t.
+
+Tue Sep 24 18:18:44 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * Make-lang.in (exception.o): Turn off pic.
+
+ * tinfo2.cc (__throw_type_match_rtti): Fix cv-variants of the same
+ type, multi-level ptr conversions.
+
+ * rtti.c (call_void_fn): Renamed and genericized from throw_bad_cast.
+ (throw_bad_cast): Use it.
+ (throw_bad_typeid): New fn.
+ (build_typeid): Throw bad_typeid as needed.
+ Use build_call.
+ (synthesize_tinfo_fn): Handle functions and arrays before checking
+ for cv-quals.
+
+ * Remove .h from standard C++ headers, add new.h, move into inc
+ subdirectory.
+
+ * exception*: Remove pointer from object, constructors. Add
+ default exception::what that uses type_info::name. Add
+ __throw_bad_typeid.
+
+ * init.c (build_new): Don't add a cookie to new (void *) T[2].
+
+Mon Sep 23 15:21:53 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * Make-lang.in: Building C++ code depends on cc1plus.
+
+Mon Sep 23 12:38:40 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * decl.c (struct saved_scope): Declare PROCESSING_TEMPLATE_DECL as
+ a HOST_WIDE_INT, not a tree.
+
+Mon Sep 23 12:36:02 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * exception.cc: Don't include <stdlib.h>.
+
+ * Make-lang.in (c++.clean): Remove cplib2.*.
+
+Mon Sep 23 09:42:19 1996 Doug Evans <dje@canuck.cygnus.com>
+
+ * parse.y (component_decl_1, component_costructor_declarator case):
+ Pass attributes/prefix_attributes in tree list.
+
+Mon Sep 23 01:18:50 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * tinfo{,2}.cc: #include <stddef.h> instead of <stdlib.h>.
+
+Sun Sep 22 05:31:22 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * lex.c (do_identifier): Don't do deferred lookup in a template
+ header.
+
+ * typeck2.c (store_init_value): Oops.
+
+ * new.{h,cc}, exception.{h,cc}, typeinfo.h, tinfo{2.cc,.cc,.h}:
+ New files for C++ lang-support library.
+ * Make-lang.in (CXX_EXTRA_HEADERS): Define.
+ (CXX_LIB2FUNCS): Define.
+ And rules for building the C++ lang-support code.
+ * config-lang.in (headers): Define.
+ (lib2funcs): Define.
+
+Sat Sep 21 19:17:28 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * decl2.c (build_expr_from_tree): If CONSTRUCTOR has a type, call
+ digest_init.
+ * pt.c (tsubst_copy): Compute type for CONSTRUCTOR.
+ * typeck2.c (store_init_value): Check for initializing pmf with { }
+ here.
+ (process_init_constructor): Not here.
+
+Thu Sep 19 16:41:07 1996 Jason Merrill <jason@yorick.cygnus.com>
+
+ * pt.c (begin_template_parm_list): Increment
+ processing_template_decl here.
+ (end_template_parm_list): Not here.
+ (process_template_parm): No need to add 1 to it now.
+ * *.c: Use processing_template_decl instead of current_template_parms
+ to check for being in a template.
+
+ * pt.c (uses_template_parms): Handle SCOPE_REF. Fix CONSTRUCTOR.
+ (tsubst_copy): Handle CONSTRUCTOR.
+ (instantiate_decl): Set up context properly for variables.
+ * decl2.c (build_expr_from_tree): Handle CONSTRUCTOR.
+ * class.c (finish_struct): Reverse CLASSTYPE_TAGS.
+
+Wed Sep 18 13:30:20 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
+
+ * lex.c (enum tree_node_kind) [GATHER_STATISTICS]: Put the enum back.
+
Wed Sep 18 04:24:07 1996 Jason Merrill <jason@yorick.cygnus.com>
* method.c (make_thunk): Call comdat_linkage before setting the
# The name to use for the demangler program.
DEMANGLER_PROG = c++filt
+
+# Extra headers to install.
+CXX_EXTRA_HEADERS = $(srcdir)/cp/inc/typeinfo $(srcdir)/cp/inc/exception \
+ $(srcdir)/cp/inc/new $(srcdir)/cp/inc/new.h
+
+# Extra code to include in libgcc2.
+CXX_LIB2FUNCS = tinfo.o tinfo2.o new.o exception.o
+CXX_LIB2SRCS = $(srcdir)/cp/new.cc $(srcdir)/cp/exception.cc \
+ $(srcdir)/cp/tinfo.cc $(srcdir)/cp/tinfo2.cc $(srcdir)/cp/tinfo.h
\f
# Define the names for selecting c++ in LANGUAGES.
# Note that it would be nice to move the dependency on g++
c++.info:
c++.dvi:
+
+# C++ language-support library pieces for libgcc.
+tinfo.o: cc1plus $(srcdir)/cp/tinfo.cc
+ $(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(INCLUDES) \
+ -c $(srcdir)/cp/tinfo.cc
+tinfo2.o: cc1plus $(srcdir)/cp/tinfo2.cc
+ $(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(INCLUDES) \
+ -c $(srcdir)/cp/tinfo2.cc
+exception.o: cc1plus $(srcdir)/cp/exception.cc
+ $(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(INCLUDES) \
+ -c -O0 -fexceptions $(srcdir)/cp/exception.cc
+new.o: cc1plus $(srcdir)/cp/new.cc
+ $(GCC_FOR_TARGET) $(LIBGCC2_CFLAGS) $(INCLUDES) \
+ -c $(srcdir)/cp/new.cc
+
+# We want to update cplib2.txt if any of the source files change...
+cplib2.txt: $(CXX_LIB2SRCS) $(CXX_EXTRA_HEADERS) cplib2.ready
+ if [ -f cc1plus ]; then \
+ echo $(CXX_LIB2FUNCS) > cplib2.new; \
+ else \
+ echo "" > cplib2.new; \
+ fi
+ mv -f cplib2.new cplib2.txt
+
+# Or if it would be different.
+cplib2.ready: $(GCC_PASSES) $(LIBGCC2_DEPS) stmp-int-hdrs
+ @if [ -r cplib2.txt ]; then \
+ if [ -f cc1plus ]; then \
+ echo $(CXX_LIB2FUNCS) > cplib2.new; \
+ else \
+ echo "" > cplib2.new; \
+ fi; \
+ if cmp -s cplib2.new cplib2.txt; then \
+ touch cplib2.ready; \
+ fi; \
+ rm -f cplib2.new; \
+ fi
+ @if [ -f cplib2.ready ]; then true; else \
+ touch cplib2.ready; \
+ fi
\f
# Install hooks:
# cc1plus is installed elsewhere as part of $(COMPILERS).
c++.mostlyclean:
-rm -f cp/*$(objext) $(DEMANGLER_PROG)
c++.clean:
+ -rm -f cplib2.txt cplib2.ready
c++.distclean:
-rm -f cp/config.status cp/Makefile
-rm -f cp/parse.output
|| basetype == error_mark_node)
return error_mark_node;
- if (current_template_parms)
+ if (processing_template_decl)
{
if (TREE_CODE (name) == BIT_NOT_EXPR)
{
|| (instance != NULL_TREE && TREE_TYPE (instance) == error_mark_node))
return error_mark_node;
- if (current_template_parms)
+ if (processing_template_decl)
{
if (TREE_CODE (name) == BIT_NOT_EXPR)
{
if (arg3 && TREE_CODE (arg3) == OFFSET_REF)
arg3 = resolve_offset_ref (arg3);
- if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
- && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2)))
- && (! arg3 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
+ if (code == COND_EXPR)
+ {
+ if (TREE_CODE (TREE_TYPE (arg2)) == VOID_TYPE
+ || TREE_CODE (TREE_TYPE (arg3)) == VOID_TYPE
+ || (! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))
+ && ! IS_OVERLOAD_TYPE (TREE_TYPE (arg3))))
+ goto builtin;
+ }
+ else if (! IS_OVERLOAD_TYPE (TREE_TYPE (arg1))
+ && (! arg2 || ! IS_OVERLOAD_TYPE (TREE_TYPE (arg2))))
goto builtin;
if (code == POSTINCREMENT_EXPR || code == POSTDECREMENT_EXPR)
case IDENTITY_CONV:
if (type_unknown_p (expr))
expr = instantiate_type (TREE_TYPE (convs), expr, 1);
+ if (TREE_READONLY_DECL_P (expr))
+ expr = decl_constant_value (expr);
return expr;
case AMBIG_CONV:
/* Call build_user_type_conversion again for the error. */
defined for this type. */
if (CLASSTYPE_TAGS (t) || dummy)
{
- x = CLASSTYPE_TAGS (t);
+ /* The list of tags was built up in pushtag in reverse order; we need
+ to fix that so that enumerators will be processed in forward order
+ in template instantiation. */
+ CLASSTYPE_TAGS (t) = x = nreverse (CLASSTYPE_TAGS (t));
while (x)
{
tree tag = TYPE_NAME (TREE_VALUE (x));
stagestuff="g++\$(exeext) g++-cross\$(exeext) cc1plus\$(exeext)"
diff_excludes="-x cp/parse.c -x cp/parse.h"
+
+headers='$(CXX_EXTRA_HEADERS)'
+
+lib2funcs=cplib2.txt
DEFTREECODE (SIZEOF_EXPR, "sizeof_expr", "1", 1)
DEFTREECODE (ARROW_EXPR, "arrow_expr", "e", 1)
DEFTREECODE (DOTSTAR_EXPR, "dotstar_expr", "e", 2)
+DEFTREECODE (TYPEID_EXPR, "typeid_expr", "e", 1)
DEFTREECODE (EXPR_STMT, "expr_stmt", "e", 1)
DEFTREECODE (COMPOUND_STMT, "compound_stmt", "e", 1)
/* in rtti.c */
extern tree get_tinfo_fn PROTO((tree));
+extern tree get_tinfo_fn_dynamic PROTO((tree));
extern tree build_typeid PROTO((tree));
+extern tree build_x_typeid PROTO((tree));
extern tree get_typeid PROTO((tree));
extern tree build_dynamic_cast PROTO((tree, tree));
extern tree build_object_ref PROTO((tree, tree, tree));
extern tree build_component_ref_1 PROTO((tree, tree, int));
extern tree build_component_ref PROTO((tree, tree, tree, int));
+extern tree build_x_component_ref PROTO((tree, tree, tree, int));
extern tree build_x_indirect_ref PROTO((tree, char *));
extern tree build_indirect_ref PROTO((tree, char *));
extern tree build_x_array_ref PROTO((tree, tree));
int minimal_parse_mode;
tree last_function_parms;
tree template_parms;
+ HOST_WIDE_INT processing_template_decl;
tree previous_class_type, previous_class_values;
};
static struct saved_scope *current_saved_scope;
s->minimal_parse_mode = minimal_parse_mode;
s->last_function_parms = last_function_parms;
s->template_parms = current_template_parms;
+ s->processing_template_decl = processing_template_decl;
s->previous_class_type = previous_class_type;
s->previous_class_values = previous_class_values;
minimal_parse_mode = 0;
previous_class_type = previous_class_values = NULL_TREE;
if (!pseudo)
- current_template_parms = NULL_TREE;
+ {
+ current_template_parms = NULL_TREE;
+ processing_template_decl = 0;
+ }
s->prev = current_saved_scope;
s->old_bindings = old_bindings;
minimal_parse_mode = s->minimal_parse_mode;
last_function_parms = s->last_function_parms;
current_template_parms = s->template_parms;
+ processing_template_decl = s->processing_template_decl;
previous_class_type = s->previous_class_type;
previous_class_values = s->previous_class_values;
TYPE_NAME (type) = d;
DECL_CONTEXT (d) = context;
- if (! globalize && current_template_parms && IS_AGGR_TYPE (type))
+ if (! globalize && processing_template_decl && IS_AGGR_TYPE (type))
push_template_decl (d);
/* If it is anonymous, then we are called from pushdecl,
TYPE_MAIN_DECL (type) = d;
DECL_CONTEXT (d) = context;
- if (! globalize && current_template_parms && IS_AGGR_TYPE (type))
+ if (! globalize && processing_template_decl && IS_AGGR_TYPE (type))
push_template_decl (d);
d = pushdecl_class_level (d);
/* Lay the type out, unless already done. */
if (oldtype != TREE_TYPE (newdecl)
&& TREE_TYPE (newdecl) != error_mark_node
- && !(current_template_parms && uses_template_parms (newdecl)))
+ && !(processing_template_decl && uses_template_parms (newdecl)))
layout_type (TREE_TYPE (newdecl));
if ((TREE_CODE (newdecl) == VAR_DECL
|| TREE_CODE (newdecl) == RESULT_DECL
|| TREE_CODE (newdecl) == FIELD_DECL
|| TREE_CODE (newdecl) == TYPE_DECL)
- && !(current_template_parms && uses_template_parms (newdecl)))
+ && !(processing_template_decl && uses_template_parms (newdecl)))
layout_decl (newdecl, 0);
/* Merge the type qualifiers. */
else if (TREE_CODE (name) != IDENTIFIER_NODE)
my_friendly_abort (2000);
- if (! current_template_parms
+ if (! processing_template_decl
|| ! uses_template_parms (context)
|| context == current_class_type)
{
return TREE_TYPE (t);
}
- if (current_template_parms)
+ if (processing_template_decl)
push_obstacks (&permanent_obstack, &permanent_obstack);
t = make_lang_type (TYPENAME_TYPE);
d = build_decl (TYPE_DECL, name, t);
- if (current_template_parms)
+ if (processing_template_decl)
pop_obstacks ();
TYPE_CONTEXT (t) = context;
val = lookup_namespace_name (type, name);
}
else if (! IS_AGGR_TYPE (type)
- || TREE_CODE (type) == TEMPLATE_TYPE_PARM)
+ || TREE_CODE (type) == TEMPLATE_TYPE_PARM
+ || TREE_CODE (type) == TYPENAME_TYPE)
/* Someone else will give an error about this if needed. */
val = NULL_TREE;
else if (TYPE_BEING_DEFINED (type))
val = NULL_TREE;
#if 1
- if (got_scope && current_template_parms
+ if (got_scope && processing_template_decl
&& got_scope != current_class_type
&& uses_template_parms (got_scope)
&& val && TREE_CODE (val) == TYPE_DECL
record_builtin_type (RID_MAX, "long long unsigned",
long_long_unsigned_type_node);
+ short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
+ record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
+ short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
+ record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
+ 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',
TREE_TYPE (TYPE_SIZE (long_integer_type_node)) = sizetype;
TREE_TYPE (TYPE_SIZE (long_long_integer_type_node)) = sizetype;
TREE_TYPE (TYPE_SIZE (long_long_unsigned_type_node)) = sizetype;
-
- short_integer_type_node = make_signed_type (SHORT_TYPE_SIZE);
- record_builtin_type (RID_SHORT, "short int", short_integer_type_node);
- short_unsigned_type_node = make_unsigned_type (SHORT_TYPE_SIZE);
- record_builtin_type (RID_MAX, "short unsigned int", short_unsigned_type_node);
- record_builtin_type (RID_MAX, "unsigned short", short_unsigned_type_node);
+ TREE_TYPE (TYPE_SIZE (short_integer_type_node)) = sizetype;
+ TREE_TYPE (TYPE_SIZE (short_unsigned_type_node)) = sizetype;
/* Define both `signed char' and `unsigned char'. */
signed_char_type_node = make_signed_type (CHAR_TYPE_SIZE);
&& TYPE_SIZE (value) == NULL_TREE)
{
SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (value);
- if (current_template_parms)
+ if (processing_template_decl)
push_template_decl (TYPE_MAIN_DECL (value));
}
else if (CLASSTYPE_TEMPLATE_INSTANTIATION (value))
type = TREE_TYPE (decl);
/* Don't lose if destructors must be executed at file-level. */
- if (! current_template_parms && TREE_STATIC (decl)
+ if (! processing_template_decl && TREE_STATIC (decl)
&& TYPE_NEEDS_DESTRUCTOR (complete_type (type))
&& !TREE_PERMANENT (decl))
{
break;
default:
- if (TREE_CODE (type) == ARRAY_TYPE && ! current_template_parms
- && TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
+ if (! processing_template_decl)
{
- cp_error ("elements of array `%#D' have incomplete type", decl);
- initialized = 0;
+ if (TYPE_SIZE (type) != NULL_TREE
+ && ! TREE_CONSTANT (TYPE_SIZE (type)))
+ {
+ cp_error
+ ("variable-sized object `%D' may not be initialized", decl);
+ initialized = 0;
+ }
+
+ if (TREE_CODE (type) == ARRAY_TYPE
+ && TYPE_SIZE (complete_type (TREE_TYPE (type))) == NULL_TREE)
+ {
+ cp_error
+ ("elements of array `%#D' have incomplete type", decl);
+ initialized = 0;
+ }
}
}
else
tem = pushdecl (decl);
- if (current_template_parms)
+ if (processing_template_decl)
{
if (! current_function_decl)
push_template_decl (tem);
DECL_COMMON (tem) = flag_conserve_space || ! TREE_PUBLIC (tem);
#endif
- if (! current_template_parms)
+ if (! processing_template_decl)
start_decl_1 (tem);
/* Corresponding pop_obstacks is done in `cp_finish_decl'. */
use temporary storage. Do this even if we will ignore the value. */
if (toplevel_bindings_p () && debug_temp_inits)
{
- if (current_template_parms
+ if (processing_template_decl
|| TYPE_NEEDS_CONSTRUCTING (type)
|| TREE_CODE (type) == REFERENCE_TYPE)
/* In this case, the initializer must lay down in permanent
&& TREE_CODE (decl) != TEMPLATE_DECL
&& IS_AGGR_TYPE (type) && ! DECL_EXTERNAL (decl))
{
- if ((! current_template_parms || ! uses_template_parms (type))
+ if ((! processing_template_decl || ! uses_template_parms (type))
&& TYPE_SIZE (complete_type (type)) == NULL_TREE)
{
cp_error ("aggregate `%#D' has incomplete type and cannot be initialized",
return;
}
- if (current_template_parms)
+ if (processing_template_decl)
{
if (init && DECL_INITIAL (decl))
DECL_INITIAL (decl) = init;
/* If requested, warn about definitions of large data objects. */
if (warn_larger_than
- && ! current_template_parms
+ && ! processing_template_decl
&& (TREE_CODE (decl) == VAR_DECL || TREE_CODE (decl) == PARM_DECL)
&& !DECL_EXTERNAL (decl))
{
/* If this involves a template parameter, it'll be
constant, but we don't know what the value is yet. */
- if (current_template_parms)
+ if (processing_template_decl)
{
itype = make_node (INTEGER_TYPE);
TYPE_MIN_VALUE (itype) = size_zero_node;
}
if (current_lang_name == lang_name_cplusplus
- && ! current_template_parms
+ && ! processing_template_decl
&& ! (IDENTIFIER_LENGTH (original_name) == 4
&& IDENTIFIER_POINTER (original_name)[0] == 'm'
&& strcmp (IDENTIFIER_POINTER (original_name), "main") == 0)
any_init++;
if (TREE_CODE (init) == SAVE_EXPR)
PARM_DECL_EXPR (init) = 1;
- else if (current_template_parms)
+ else if (processing_template_decl)
;
else if (TREE_CODE (init) == VAR_DECL
|| TREE_CODE (init) == PARM_DECL)
}
else
init = require_instantiated_type (type, init, integer_zero_node);
- if (! current_template_parms
+ if (! processing_template_decl
&& ! can_convert_arg (type, TREE_TYPE (init), init))
cp_pedwarn ("invalid type `%T' for default argument to `%#D'",
TREE_TYPE (init), decl);
{
if ((name == ansi_opname[(int) POSTINCREMENT_EXPR]
|| name == ansi_opname[(int) POSTDECREMENT_EXPR])
- && ! current_template_parms
+ && ! processing_template_decl
&& TREE_VALUE (TREE_CHAIN (argtypes)) != integer_type_node)
{
if (methodp)
register tree pair;
register tree value = DECL_INITIAL (TREE_VALUE (values));
- if (! current_template_parms)
+ if (! processing_template_decl)
{
/* Speed up the main loop by performing some precalculations */
TREE_TYPE (TREE_VALUE (values)) = enumtype;
for (pair = TREE_CHAIN (values); pair; pair = TREE_CHAIN (pair))
{
value = DECL_INITIAL (TREE_VALUE (pair));
- if (! current_template_parms)
+ if (! processing_template_decl)
{
TREE_TYPE (TREE_VALUE (pair)) = enumtype;
TREE_TYPE (value) = enumtype;
TYPE_VALUES (enumtype) = values;
- if (current_template_parms)
+ if (processing_template_decl)
return enumtype;
{
if (value)
STRIP_TYPE_NOPS (value);
- if (! current_template_parms)
+ if (! processing_template_decl)
{
/* Validate and default VALUE. */
if (value != NULL_TREE)
}
/* Default based on previous value. */
- if (value == NULL_TREE && ! current_template_parms)
+ if (value == NULL_TREE && ! processing_template_decl)
{
value = enum_next_value;
if (enum_overflow)
GNU_xref_decl (current_function_decl, decl);
}
- if (! current_template_parms)
+ if (! processing_template_decl)
{
/* Set basis for default for next value. */
enum_next_value = build_binary_op_nodefault (PLUS_EXPR, value,
announce_function (decl1);
- if (! current_template_parms)
+ if (! processing_template_decl)
{
if (TYPE_SIZE (complete_type (TREE_TYPE (fntype))) == NULL_TREE)
{
If we already have a decl for this name, and it is a FUNCTION_DECL,
use the old decl. */
- if (current_template_parms)
+ if (processing_template_decl)
push_template_decl (decl1);
else if (pre_parsed_p == 0)
{
|| flag_alt_external_templates))
{
if (DECL_THIS_INLINE (decl1) || DECL_TEMPLATE_INSTANTIATION (decl1)
- || current_template_parms)
+ || processing_template_decl)
DECL_EXTERNAL (decl1)
= (interface_only
|| (DECL_THIS_INLINE (decl1) && ! flag_implement_inlines));
of this function only. Tiemann moved up here from bottom of fn. */
temporary_allocation ();
- if (current_template_parms)
+ if (processing_template_decl)
{
extern tree last_tree;
++minimal_parse_mode;
pushdecl (parm);
}
- if (! current_template_parms
+ if (! processing_template_decl
&& (cleanup = maybe_build_cleanup (parm), cleanup))
{
expand_decl (parm);
/* Initialize the RTL code for the function. */
DECL_SAVED_INSNS (fndecl) = NULL_RTX;
- if (! current_template_parms)
+ if (! processing_template_decl)
expand_function_start (fndecl, parms_have_cleanups);
/* Create a binding contour which can be used to catch
}
/* Take care of exception handling things. */
- if (! current_template_parms && flag_exceptions)
+ if (! processing_template_decl && flag_exceptions)
{
rtx insns;
start_sequence ();
store_parm_decls ();
}
- if (current_template_parms)
+ if (processing_template_decl)
{
if (DECL_CONSTRUCTOR_P (fndecl) && call_poplevel)
{
to the FUNCTION_DECL node itself. */
BLOCK_SUPERCONTEXT (DECL_INITIAL (fndecl)) = fndecl;
- if (! current_template_parms)
+ if (! processing_template_decl)
{
/* So we can tell if jump_optimize sets it to 1. */
can_reach_end = 0;
/* Free all the tree nodes making up this function. */
/* Switch back to allocating nodes permanently
until we start another function. */
- if (current_template_parms)
+ if (processing_template_decl)
{
--minimal_parse_mode;
DECL_SAVED_TREE (fndecl) = TREE_CHAIN (DECL_SAVED_TREE (fndecl));
was an actual function definition. */
DECL_INITIAL (fndecl) = error_mark_node;
/* And we need the arguments for template instantiation. */
- if (! current_template_parms)
+ if (! processing_template_decl)
{
if (! DECL_CONSTRUCTOR_P (fndecl)
|| !(TYPE_USES_VIRTUAL_BASECLASSES
if (flag_default_inline)
DECL_INLINE (fndecl) = 1;
- if (current_template_parms && ! current_function_decl)
+ if (processing_template_decl && ! current_function_decl)
push_template_decl (fndecl);
/* We read in the parameters on the maybepermanent_obstack,
push_temp_slots ();
target_temp_slot_level = temp_slot_level;
- if (current_template_parms)
+ if (processing_template_decl)
{
add_tree (build_min_nt (EXPR_STMT, exp));
return;
if (type == error_mark_node || index_exp == error_mark_node)
return error_mark_node;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min (ARRAY_REF, type ? TREE_TYPE (type) : NULL_TREE,
array_expr, index_exp);
if (exp == error_mark_node)
return exp;
- if (current_template_parms)
+ if (processing_template_decl)
{
t = build_min (DELETE_EXPR, void_type_node, exp, size);
DELETE_EXPR_USE_GLOBAL (t) = use_global_delete;
because `decl_const_value' would mis-interpret it
as only meaning that this VAR_DECL is defined. */
init = build1 (NOP_EXPR, TREE_TYPE (value), init);
- else if (current_template_parms)
+ else if (processing_template_decl)
;
else if (! TREE_CONSTANT (init))
{
/* The corresponding pop_obstacks is in cp_finish_decl. */
push_obstacks_nochange ();
- if (current_template_parms && ! current_function_decl
+ if (processing_template_decl && ! current_function_decl
&& (TREE_CODE (value) == VAR_DECL || TREE_CODE (value) == FUNCTION_DECL))
push_template_decl (value);
DECL_ASSEMBLER_NAME (value)
= build_static_name (current_class_type, DECL_NAME (value));
}
- if (! current_template_parms)
+ if (! processing_template_decl)
pending_statics = perm_tree_cons (NULL_TREE, value, pending_statics);
/* Static consts need not be initialized in the class definition. */
if (base_init_expr == 0
&& DECL_CONSTRUCTOR_P (current_function_decl))
{
- if (current_template_parms)
+ if (processing_template_decl)
add_tree (build_min_nt
(CTOR_INITIALIZER,
current_member_init_list, current_base_init_list));
}
case COMPONENT_REF:
- return build_component_ref
+ return build_x_component_ref
(build_expr_from_tree (TREE_OPERAND (t, 0)),
TREE_OPERAND (t, 1), NULL_TREE, 1);
case THROW_EXPR:
return build_throw (build_expr_from_tree (TREE_OPERAND (t, 0)));
+ case CONSTRUCTOR:
+ {
+ tree r = build_nt (CONSTRUCTOR, NULL_TREE,
+ build_expr_from_tree (CONSTRUCTOR_ELTS (t)));
+
+ if (TREE_TYPE (t))
+ return digest_init (TREE_TYPE (t), r, 0);
+ return r;
+ }
+
+ case TYPEID_EXPR:
+ return build_x_typeid (build_expr_from_tree (TREE_OPERAND (t, 0)));
+
default:
return t;
}
tree decl;
{
TREE_USED (decl) = 1;
- if (current_template_parms)
+ if (processing_template_decl)
return;
assemble_external (decl);
/* Is it a synthesized method that needs to be synthesized? */
case ARRAY_TYPE:
OB_PUTC ('[');
if (TYPE_DOMAIN (t))
- OB_PUTI (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) + 1);
+ {
+ if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == INTEGER_CST)
+ OB_PUTI (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) + 1);
+ else if (TREE_CODE (TYPE_MAX_VALUE (TYPE_DOMAIN (t))) == MINUS_EXPR)
+ dump_expr (TREE_OPERAND (TYPE_MAX_VALUE (TYPE_DOMAIN (t)), 0), 0);
+ else
+ dump_expr (fold (build_binary_op
+ (PLUS_EXPR, TYPE_MAX_VALUE (TYPE_DOMAIN (t)),
+ integer_one_node, 1)), 0);
+ }
OB_PUTC (']');
dump_type_suffix (TREE_TYPE (t), v);
break;
{
if (e != error_mark_node)
{
- if (current_template_parms)
+ if (processing_template_decl)
return build_min (THROW_EXPR, void_type_node, e);
e = build1 (THROW_EXPR, void_type_node, e);
TREE_SIDE_EFFECTS (e) = 1;
--- /dev/null
+// Functions for Exception Support for -*- C++ -*-
+// Copyright (C) 1994, 1995, 1996 Free Software Foundation
+
+// This file is part of GNU CC.
+
+// GNU CC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// GNU CC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GNU CC; see the file COPYING. If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+// As a special exception, if you link this library with other files,
+// some of which are compiled with GCC, to produce an executable,
+// this library does not by itself cause the resulting executable
+// to be covered by the GNU General Public License.
+// This exception does not however invalidate any other reasons why
+// the executable file might be covered by the GNU General Public License.
+
+#pragma implementation "exception"
+
+#include "typeinfo"
+#include "exception"
+
+/* terminate (), unexpected (), set_terminate (), set_unexpected () as
+ well as the default terminate func and default unexpected func */
+
+void
+__default_terminate ()
+{
+ abort ();
+}
+
+void
+__default_unexpected ()
+{
+ __default_terminate ();
+}
+
+static terminate_handler __terminate_func = __default_terminate;
+static unexpected_handler __unexpected_func = __default_unexpected;
+
+terminate_handler
+set_terminate (terminate_handler func)
+{
+ terminate_handler old = __terminate_func;
+
+ __terminate_func = func;
+ return old;
+}
+
+unexpected_handler
+set_unexpected (unexpected_handler func)
+{
+ unexpected_handler old = __unexpected_func;
+
+ __unexpected_func = func;
+ return old;
+}
+
+void
+terminate ()
+{
+ __terminate_func ();
+}
+
+void
+unexpected ()
+{
+ __unexpected_func ();
+}
+
+extern "C" void
+__throw_bad_cast (void)
+{
+ throw bad_cast ();
+}
+
+extern "C" void
+__throw_bad_typeid (void)
+{
+ throw bad_typeid ();
+}
+
+extern "C" void
+__throw_bad_exception (void)
+{
+ throw bad_exception ();
+}
+
+bool
+uncaught_exception ()
+{
+ extern void *__eh_type;
+ extern bool __eh_in_catch;
+ return __eh_type && ! __eh_in_catch;
+}
+
+const char * exception::
+what () const
+{
+ return typeid (*this).name ();
+}
if (end && pedantic)
pedwarn ("ANSI C++ forbids range expressions in switch statement");
- if (current_template_parms)
+ if (processing_template_decl)
{
add_tree (build_min_nt (CASE_LABEL, start, end));
return;
that throws exceptions as a side effect, like dynamic casting, and all
code that catches exceptions must be compiled with either -frtti, or
-fno-rtti. It is not possible to mix rtti base exception handling
-objects with code that doesn't use rtti. Also, -frtti can alter the
-binary layout of classes, so mixing -frtti code and -fno-rtti code can
-be dangerous. The exceptions to this, are code that doesn't catch or
-throw exceptions, catch (...), and code that just rethrows an exception.
+objects with code that doesn't use rtti. The exceptions to this, are
+code that doesn't catch or throw exceptions, catch (...), and code that
+just rethrows an exception.
Currently we use the normal mangling used in building functions names
(int's are "i", const char * is PCc) to build the non-rtti base type
--- /dev/null
+// Exception Handling support header for -*- C++ -*-
+// Copyright (C) 1995, 1996 Free Software Foundation
+
+#ifndef __EXCEPTION__
+#define __EXCEPTION__
+
+#pragma interface "exception"
+
+extern "C++" {
+
+#if 0
+namespace std {
+#endif
+
+class exception {
+public:
+ exception () { }
+ virtual ~exception () { }
+ virtual const char* what () const;
+};
+
+class bad_exception : public exception {
+public:
+ bad_exception () { }
+ virtual ~bad_exception () { }
+};
+
+typedef void (*terminate_handler) ();
+typedef void (*unexpected_handler) ();
+
+terminate_handler set_terminate (terminate_handler);
+void terminate (void);
+unexpected_handler set_unexpected (unexpected_handler);
+void unexpected (void);
+bool uncaught_exception ();
+} // extern "C++"
+
+#if 0
+} // namespace std
+#endif
+
+#endif
--- /dev/null
+// The -*- C++ -*- dynamic memory management header.
+// Copyright (C) 1994, 1996 Free Software Foundation
+
+#ifndef __NEW__
+#define __NEW__
+
+#pragma interface "new"
+#include <stddef.h>
+
+extern "C++" {
+
+#if 0
+namespace std {
+#endif
+
+typedef void (*new_handler)();
+extern "C" new_handler set_new_handler (new_handler);
+
+#if 0
+} // namespace std
+#endif
+
+// G++ implementation internals
+extern new_handler __new_handler;
+extern "C" void __default_new_handler (void);
+
+// replaceable signatures
+void *operator new (size_t);
+void *operator new[] (size_t);
+void operator delete (void *);
+void operator delete[] (void *);
+
+// default placement versions of operator new
+inline void *operator new(size_t, void *place) { return place; }
+inline void *operator new[](size_t, void *place) { return place; }
+} // extern "C++"
+
+#endif
--- /dev/null
+// -*- C++ -*- forwarding header.
+
+#ifndef __NEW_H__
+#define __NEW_H__
+
+#include <new>
+
+#if 0
+using std::new_handler;
+using std::set_new_handler;
+#endif
+
+#endif // __NEW_H__
--- /dev/null
+// RTTI support for -*- C++ -*-
+// Copyright (C) 1994, 1995, 1996 Free Software Foundation
+
+#ifndef __TYPEINFO__
+#define __TYPEINFO__
+
+#include <exception>
+
+extern "C++" {
+
+#if 0
+namespace std {
+#endif
+
+class type_info {
+private:
+ // assigning type_info is not supported. made private.
+ type_info& operator= (const type_info&);
+ type_info (const type_info&);
+
+protected:
+ type_info (const char *n): _name (n) { }
+
+ const char *_name;
+
+public:
+ // destructor
+ virtual ~type_info ();
+
+ bool before (const type_info& arg);
+ const char* name () const
+ { return _name; }
+ bool operator== (const type_info& arg) const;
+ bool operator!= (const type_info& arg) const;
+};
+
+// We can't rely on common symbols being shared between translation units
+// under Windows. Sigh.
+
+#ifndef _WIN32
+inline bool type_info::
+operator== (const type_info& arg) const
+{
+ return &arg == this;
+}
+
+inline bool type_info::
+operator!= (const type_info& arg) const
+{
+ return &arg != this;
+}
+#endif
+
+class bad_cast : public exception {
+public:
+ bad_cast() { }
+ virtual ~bad_cast() { }
+};
+
+class bad_typeid : public exception {
+ public:
+ bad_typeid () { }
+ virtual ~bad_typeid () { }
+};
+
+#if 0
+} // namespace std
+#endif
+
+} // extern "C++"
+#endif
tree basebinfo = NULL_TREE;
int dtor = 0;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (SCOPE_REF, type, name);
/* Handle namespace names fully here. */
tree alloc_expr, alloc_temp;
int has_array = 0;
enum tree_code code = NEW_EXPR;
+ int use_cookie;
tree pending_sizes = NULL_TREE;
{
if (this_nelts == NULL_TREE)
error ("new of array type fails to specify size");
- else if (current_template_parms)
+ else if (processing_template_decl)
{
nelts = this_nelts;
absdcl = TREE_OPERAND (absdcl, 0);
decl = TYPE_NAME (type);
}
- if (current_template_parms)
+ if (processing_template_decl)
{
tree t;
if (has_array)
return error_mark_node;
}
+#if 1
/* Get a little extra space to store a couple of things before the new'ed
- array. */
- if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type))
+ array, if this isn't the default placement new. */
+
+ use_cookie = (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type)
+ && ! (placement && ! TREE_CHAIN (placement)
+ && TREE_TYPE (TREE_VALUE (placement)) == ptr_type_node));
+#else
+ /* Get a little extra space to store a couple of things before the new'ed
+ array, if this is either non-placement new or new (nothrow). */
+
+ use_cookie = (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type)
+ && (! placement
+ || (IS_AGGR_TYPE (TREE_TYPE (placement))
+ && (TYPE_IDENTIFIER (TREE_TYPE (placement))
+ == get_identifier ("nothrow_t")))));
+#endif
+
+ if (use_cookie)
{
tree extra = BI_header_size;
sure we have some extra bytes in that case for the BI_header_size
cookies? And how does that interact with the code below? (mrs) */
/* Finish up some magic for new'ed arrays */
- if (has_array && TYPE_VEC_NEW_USES_COOKIE (true_type) && rval != NULL_TREE)
+ if (use_cookie && rval != NULL_TREE)
{
tree extra = BI_header_size;
tree cookie, exp1;
return getch ();
}
if (input)
- return input->str[input->offset++];
+ return (unsigned char)input->str[input->offset++];
}
return getc (finput);
}
cp_error ("enum `%D' is private", id);
/* protected is OK, since it's an enum of `this'. */
}
- if (! current_template_parms
+ if (! processing_template_decl
|| (DECL_INITIAL (id)
&& TREE_CODE (DECL_INITIAL (id)) == TEMPLATE_CONST_PARM))
id = DECL_INITIAL (id);
yychar = yylex ();
if (! id)
{
- if (current_template_parms)
+ if (processing_template_decl)
{
id = build_min_nt (LOOKUP_EXPR, token, NULL_TREE);
LOOKUP_EXPR_GLOBAL (id) = 1;
else if (TREE_CODE (id) != TREE_LIST)
mark_used (id);
}
- if (TREE_CODE (id) == CONST_DECL && ! current_template_parms)
+ if (TREE_CODE (id) == CONST_DECL && ! processing_template_decl)
{
/* XXX CHS - should we set TREE_USED of the constant? */
id = DECL_INITIAL (id);
TREE_CONSTANT (id) = 1;
}
- if (current_template_parms)
+ if (processing_template_decl)
{
if (is_overloaded_fn (id))
{
len = p - token_buffer - 1;
}
#endif
- if (current_template_parms)
+ if (processing_template_decl)
push_obstacks (&permanent_obstack, &permanent_obstack);
yylval.ttype = build_string ((len + 1) * WCHAR_BYTES, widep);
- if (current_template_parms)
+ if (processing_template_decl)
pop_obstacks ();
TREE_TYPE (yylval.ttype) = wchar_array_type_node;
}
else
{
- if (current_template_parms)
+ if (processing_template_decl)
push_obstacks (&permanent_obstack, &permanent_obstack);
yylval.ttype = build_string (p - token_buffer, token_buffer + 1);
- if (current_template_parms)
+ if (processing_template_decl)
pop_obstacks ();
TREE_TYPE (yylval.ttype) = char_array_type_node;
}
}
#ifdef GATHER_STATISTICS
+/* The original for tree_node_kind is in the toplevel tree.c; changes there
+ need to be brought into here, unless this were actually put into a header
+ instead. */
+/* Statistics-gathering stuff. */
+typedef enum
+{
+ d_kind,
+ t_kind,
+ b_kind,
+ s_kind,
+ r_kind,
+ e_kind,
+ c_kind,
+ id_kind,
+ op_id_kind,
+ perm_list_kind,
+ temp_list_kind,
+ vec_kind,
+ x_kind,
+ lang_decl,
+ lang_type,
+ all_kinds
+} tree_node_kind;
+
extern int tree_node_counts[];
extern int tree_node_sizes[];
#endif
OB_PUTC ('_');
return;
}
- else if (current_template_parms
+ else if (processing_template_decl
&& TREE_CODE (value) != INTEGER_CST)
/* We don't ever want this output, but it's inconvenient not to
be able to build the string. This should cause assembler
}
my_friendly_assert (TREE_CODE (value) == INTEGER_CST, 243);
- if (TYPE_PRECISION (value) == 2 * HOST_BITS_PER_WIDE_INT)
+ if (TYPE_PRECISION (TREE_TYPE (value)) == 2 * HOST_BITS_PER_WIDE_INT)
{
if (tree_int_cst_lt (value, integer_zero_node))
{
return value;
}
- if (TREE_CODE (type) == REFERENCE_TYPE && ! current_template_parms)
+ if (TREE_CODE (type) == REFERENCE_TYPE && ! processing_template_decl)
value = convert_from_reference (value);
return value;
}
--- /dev/null
+// Implementation file for the -*- C++ -*- dynamic memory management header.
+// Copyright (C) 1996 Free Software Foundation
+// This file is part of GNU CC.
+
+#pragma implementation "new"
+#include "new"
already_scoped_stmt:
'{'
{
- if (current_template_parms)
+ if (processing_template_decl)
{
$<ttype>$ = build_min_nt (COMPOUND_STMT, NULL_TREE);
COMPOUND_STMT_NO_SCOPE ($<ttype>$) = 1;
}
compstmtend
{
- if (current_template_parms)
+ if (processing_template_decl)
{
TREE_OPERAND ($<ttype>2, 0) = TREE_CHAIN ($<ttype>2);
TREE_CHAIN ($<ttype>2) = NULL_TREE;
| boolean.literal
| string
{
- if (current_template_parms)
+ if (processing_template_decl)
push_obstacks (&permanent_obstack, &permanent_obstack);
$$ = combine_strings ($$);
- if (current_template_parms)
+ if (processing_template_decl)
pop_obstacks ();
}
| '(' expr ')'
check_for_new_type ("const_cast", $3);
$$ = build_const_cast (type, $6); }
| TYPEID '(' expr ')'
- { $$ = build_typeid ($3); }
+ { $$ = build_x_typeid ($3); }
| TYPEID '(' type_id ')'
{ tree type = groktypename ($3.t);
check_for_new_type ("typeid", $3);
| overqualified_id %prec HYPERUNARY
{ $$ = build_offset_ref (OP0 ($$), OP1 ($$)); }
| overqualified_id '(' nonnull_exprlist ')'
- { if (current_template_parms)
+ { if (processing_template_decl)
$$ = build_min_nt (CALL_EXPR, copy_to_permanent ($1), $3, NULL_TREE);
else
$$ = build_member_call (OP0 ($$), OP1 ($$), $3); }
| overqualified_id LEFT_RIGHT
- { if (current_template_parms)
+ { if (processing_template_decl)
$$ = build_min_nt (CALL_EXPR, copy_to_permanent ($1),
NULL_TREE, NULL_TREE);
else
$$ = build_member_call (OP0 ($$), OP1 ($$), NULL_TREE); }
| object unqualified_id %prec UNARY
- { $$ = build_component_ref ($$, $2, NULL_TREE, 1); }
+ { $$ = build_x_component_ref ($$, $2, NULL_TREE, 1); }
| object overqualified_id %prec UNARY
- { if (current_template_parms)
+ { if (processing_template_decl)
$$ = build_min_nt (COMPONENT_REF, $1, copy_to_permanent ($2));
else
$$ = build_object_ref ($$, OP0 ($2), OP1 ($2)); }
&& TYPE_SIZE ($$) == NULL_TREE)
{
SET_CLASSTYPE_TEMPLATE_SPECIALIZATION ($$);
- if (current_template_parms)
+ if (processing_template_decl)
push_template_decl (TYPE_MAIN_DECL ($$));
}
else if (CLASSTYPE_TEMPLATE_INSTANTIATION ($$))
pushtag (TYPE_IDENTIFIER ($<ttype>0), t, 0);
$<ttype>0 = t;
}
- if (current_template_parms && TYPE_CONTEXT (t)
+ if (processing_template_decl && TYPE_CONTEXT (t)
&& ! current_class_type)
push_template_decl (TYPE_STUB_DECL (t));
pushclass (t, 0);
&& TYPE_SIZE (t) == NULL_TREE)
{
SET_CLASSTYPE_TEMPLATE_SPECIALIZATION (t);
- if (current_template_parms)
+ if (processing_template_decl)
push_template_decl (TYPE_MAIN_DECL (t));
}
else if (CLASSTYPE_TEMPLATE_INSTANTIATION (t))
$$ = grokfield ($2, specs, $5, $3,
build_tree_list ($4, attrs)); }
| component_constructor_declarator maybeasm maybe_attribute maybe_init
- { $$ = grokfield ($$, NULL_TREE, $4, $2, $3); }
+ { $$ = grokfield ($$, NULL_TREE, $4, $2,
+ build_tree_list ($3, NULL_TREE)); }
| using_decl
{ $$ = do_class_using_decl ($1); }
;
compstmt:
'{'
{
- if (current_template_parms)
+ if (processing_template_decl)
{
$<ttype>$ = build_min_nt (COMPOUND_STMT, NULL_TREE);
add_tree ($<ttype>$);
}
.pushlevel compstmtend .poplevel
{
- if (current_template_parms)
+ if (processing_template_decl)
{
TREE_OPERAND ($<ttype>2, 0) = TREE_CHAIN ($<ttype>2);
TREE_CHAIN ($<ttype>2) = NULL_TREE;
simple_if:
IF
{
- if (current_template_parms)
+ if (processing_template_decl)
{
$<ttype>$ = build_min_nt (IF_STMT, NULL_TREE, NULL_TREE,
NULL_TREE);
}
.pushlevel paren_cond_or_null
{
- if (current_template_parms)
+ if (processing_template_decl)
{
if (last_tree != $<ttype>2)
{
}
implicitly_scoped_stmt
{
- if (current_template_parms)
+ if (processing_template_decl)
{
TREE_OPERAND ($<ttype>2, 1) = TREE_CHAIN ($<ttype>2);
TREE_CHAIN ($<ttype>2) = NULL_TREE;
{ finish_stmt (); }
| .pushlevel
{
- if (current_template_parms)
+ if (processing_template_decl)
{
$<ttype>$ = build_min_nt (COMPOUND_STMT, NULL_TREE);
add_tree ($<ttype>$);
}
simple_stmt .poplevel
{
- if (current_template_parms)
+ if (processing_template_decl)
{
TREE_OPERAND ($<ttype>2, 0) = TREE_CHAIN ($<ttype>2);
TREE_CHAIN ($<ttype>2) = NULL_TREE;
| expr ';'
{
tree expr = $1;
- if (! current_template_parms)
+ if (! processing_template_decl)
{
emit_line_note (input_filename, lineno);
/* Do default conversion if safe and possibly important,
clear_momentary ();
finish_stmt (); }
| simple_if ELSE
- { if (! current_template_parms) expand_start_else (); }
+ { if (! processing_template_decl) expand_start_else (); }
implicitly_scoped_stmt
{
- if (current_template_parms)
+ if (processing_template_decl)
{
TREE_OPERAND ($<ttype>1, 2) = TREE_CHAIN ($<ttype>1);
TREE_CHAIN ($<ttype>1) = NULL_TREE;
.poplevel
{ finish_stmt (); }
| simple_if %prec IF
- { if (! current_template_parms) expand_end_cond ();
+ { if (! processing_template_decl) expand_end_cond ();
do_poplevel ();
finish_stmt (); }
| WHILE
{
- if (current_template_parms)
+ if (processing_template_decl)
{
$<ttype>$ = build_min_nt (WHILE_STMT, NULL_TREE, NULL_TREE);
add_tree ($<ttype>$);
}
.pushlevel paren_cond_or_null
{
- if (current_template_parms)
+ if (processing_template_decl)
{
if (last_tree != $<ttype>2)
{
}
already_scoped_stmt .poplevel
{
- if (current_template_parms)
+ if (processing_template_decl)
{
TREE_OPERAND ($<ttype>2, 1) = TREE_CHAIN ($<ttype>2);
TREE_CHAIN ($<ttype>2) = NULL_TREE;
}
| DO
{
- if (current_template_parms)
+ if (processing_template_decl)
{
$<ttype>$ = build_min_nt (DO_STMT, NULL_TREE, NULL_TREE);
add_tree ($<ttype>$);
}
implicitly_scoped_stmt WHILE
{
- if (current_template_parms)
+ if (processing_template_decl)
{
TREE_OPERAND ($<ttype>2, 0) = TREE_CHAIN ($<ttype>2);
TREE_CHAIN ($<ttype>2) = NULL_TREE;
}
paren_expr_or_null ';'
{
- if (current_template_parms)
+ if (processing_template_decl)
TREE_OPERAND ($<ttype>2, 1) = $6;
else
{
finish_stmt ();
}
| FOR
- { if (current_template_parms)
+ { if (processing_template_decl)
{
$<ttype>$ = build_min_nt (FOR_STMT, NULL_TREE, NULL_TREE,
NULL_TREE, NULL_TREE);
}
'(' for.init.statement
{
- if (current_template_parms)
+ if (processing_template_decl)
{
if (last_tree != $<ttype>2)
{
}
.pushlevel xcond ';'
{
- if (current_template_parms)
+ if (processing_template_decl)
{
if (last_tree != $<ttype>2)
{
/* Don't let the tree nodes for $10 be discarded
by clear_momentary during the parsing of the next stmt. */
{
- if (current_template_parms)
+ if (processing_template_decl)
TREE_OPERAND ($<ttype>2, 2) = $10;
push_momentary ();
}
already_scoped_stmt .poplevel
{
- if (current_template_parms)
+ if (processing_template_decl)
{
TREE_OPERAND ($<ttype>2, 3) = TREE_CHAIN ($<ttype>2);
TREE_CHAIN ($<ttype>2) = NULL_TREE;
finish_stmt (); }
| SWITCH .pushlevel '(' condition ')'
{
- if (current_template_parms)
+ if (processing_template_decl)
{
$<ttype>$ = build_min_nt (SWITCH_STMT, $4, NULL_TREE);
add_tree ($<ttype>$);
}
implicitly_scoped_stmt
{
- if (current_template_parms)
+ if (processing_template_decl)
{
TREE_OPERAND ($<ttype>6, 1) = TREE_CHAIN ($<ttype>6);
TREE_CHAIN ($<ttype>6) = NULL_TREE;
stmt
| BREAK ';'
{ emit_line_note (input_filename, lineno);
- if (current_template_parms)
+ if (processing_template_decl)
add_tree (build_min_nt (BREAK_STMT));
else if ( ! expand_exit_something ())
error ("break statement not within loop or switch"); }
| CONTINUE ';'
{ emit_line_note (input_filename, lineno);
- if (current_template_parms)
+ if (processing_template_decl)
add_tree (build_min_nt (CONTINUE_STMT));
else if (! expand_continue_loop (0))
error ("continue statement not within a loop"); }
}
| GOTO '*' expr ';'
{
- if (current_template_parms)
+ if (processing_template_decl)
add_tree (build_min_nt (GOTO_STMT, $3));
else
{ emit_line_note (input_filename, lineno);
}
| GOTO identifier ';'
{
- if (current_template_parms)
+ if (processing_template_decl)
add_tree (build_min_nt (GOTO_STMT, $2));
else
{
{
pushlevel (0);
declare_pseudo_global_level ();
+ ++processing_template_decl;
}
/* Process information from new template parameter NEXT and append it to the
decl = build_decl (CONST_DECL, DECL_NAME (parm), TREE_TYPE (parm));
DECL_INITIAL (decl) = tinfo;
DECL_INITIAL (parm) = tinfo;
- TEMPLATE_CONST_SET_INFO (tinfo, idx, processing_template_decl + 1);
+ TEMPLATE_CONST_SET_INFO (tinfo, idx, processing_template_decl);
}
else
{
decl = build_decl (TYPE_DECL, TREE_VALUE (parm), t);
TYPE_MAIN_DECL (t) = decl;
parm = decl;
- TEMPLATE_TYPE_SET_INFO (t, idx, processing_template_decl + 1);
+ TEMPLATE_TYPE_SET_INFO (t, idx, processing_template_decl);
}
SET_DECL_ARTIFICIAL (decl);
pushdecl (decl);
tree parm;
tree saved_parmlist = make_tree_vec (list_length (parms));
- ++processing_template_decl;
current_template_parms
= tree_cons (build_int_2 (0, processing_template_decl),
saved_parmlist, current_template_parms);
void
end_template_decl ()
{
- if (! current_template_parms)
+ if (! processing_template_decl)
return;
/* This matches the pushlevel in begin_template_parm_list. */
if (is_type)
{
val = groktypename (arg);
- if (! current_template_parms)
+ if (! processing_template_decl)
{
tree t = target_type (val);
if (IS_AGGR_TYPE (t)
{
tree t = tsubst (TREE_TYPE (parm), &TREE_VEC_ELT (vec, 0),
TREE_VEC_LENGTH (vec), in_decl);
- if (current_template_parms)
+ if (processing_template_decl)
val = arg;
else
val = digest_init (t, arg, (tree *) 0);
- if (val == error_mark_node || current_template_parms)
+ if (val == error_mark_node || processing_template_decl)
;
/* 14.2: Other template-arguments must be constant-expressions,
if (TYPE_BEING_DEFINED (ctx) && ctx == current_class_type)
{
- tree save_parms = current_template_parms;
- current_template_parms = NULL_TREE;
+ int save_temp = processing_template_decl;
+ processing_template_decl = 0;
t = xref_tag_from_type (TREE_TYPE (template), id, 0);
- current_template_parms = save_parms;
+ processing_template_decl = save_temp;
}
else
{
case TYPENAME_TYPE:
return 1;
+ case SCOPE_REF:
+ return uses_template_parms (TREE_OPERAND (t, 0));
+
case CONSTRUCTOR:
if (TREE_TYPE (t) && TYPE_PTRMEMFUNC_P (TREE_TYPE (t)))
return uses_template_parms (TYPE_PTRMEMFUNC_FN_TYPE (TREE_TYPE (t)));
- /* else fall through */
+ return uses_template_parms (TREE_OPERAND (t, 1));
default:
switch (TREE_CODE_CLASS (TREE_CODE (t)))
{
tree max = tsubst_expr (TYPE_MAX_VALUE (t), args, nargs, in_decl);
- if (current_template_parms)
+ if (processing_template_decl)
{
tree itype = make_node (INTEGER_TYPE);
TYPE_MIN_VALUE (itype) = size_zero_node;
case SIZEOF_EXPR:
case ARROW_EXPR:
case THROW_EXPR:
+ case TYPEID_EXPR:
return build1
(code, NULL_TREE,
tsubst_copy (TREE_OPERAND (t, 0), args, nargs, in_decl));
else
return t;
+ case CONSTRUCTOR:
+ return build
+ (CONSTRUCTOR, tsubst (TREE_TYPE (t), args, nargs, in_decl), NULL_TREE,
+ tsubst_copy (CONSTRUCTOR_ELTS (t), args, nargs, in_decl));
+
default:
return t;
}
if (t == NULL_TREE || t == error_mark_node)
return t;
- if (current_template_parms)
+ if (processing_template_decl)
return tsubst_copy (t, args, nargs, in_decl);
switch (TREE_CODE (t))
int nested = in_function_p ();
int d_defined;
int pattern_defined;
+ int line = lineno;
+ char *file = input_filename;
if (TREE_CODE (d) == FUNCTION_DECL)
{
variable is a static const initialized in the class body. */
if (TREE_CODE (d) == VAR_DECL
&& ! DECL_INITIAL (d) && DECL_INITIAL (pattern))
- DECL_INITIAL (d) = tsubst_expr
- (DECL_INITIAL (pattern), &TREE_VEC_ELT (args, 0),
- TREE_VEC_LENGTH (args), tmpl);
+ {
+ lineno = DECL_SOURCE_LINE (d);
+ input_filename = DECL_SOURCE_FILE (d);
+
+ pushclass (DECL_CONTEXT (d), 2);
+ DECL_INITIAL (d) = tsubst_expr
+ (DECL_INITIAL (pattern), &TREE_VEC_ELT (args, 0),
+ TREE_VEC_LENGTH (args), tmpl);
+ popclass (1);
+
+ lineno = line;
+ input_filename = file;
+ }
if (! pattern_defined
|| (TREE_CODE (d) == FUNCTION_DECL && ! DECL_INLINE (d)
push_to_top_level ();
+ lineno = DECL_SOURCE_LINE (d);
+ input_filename = DECL_SOURCE_FILE (d);
+
/* Trick tsubst into giving us a new decl in case the template changed. */
save_ti = DECL_TEMPLATE_INFO (pattern);
DECL_TEMPLATE_INFO (pattern) = NULL_TREE;
/* And set up DECL_INITIAL, since tsubst doesn't. */
if (TREE_CODE (td) == VAR_DECL)
- DECL_INITIAL (td) = tsubst_expr
- (DECL_INITIAL (pattern), &TREE_VEC_ELT (args, 0),
- TREE_VEC_LENGTH (args), tmpl);
+ {
+ pushclass (DECL_CONTEXT (d), 2);
+ DECL_INITIAL (td) = tsubst_expr
+ (DECL_INITIAL (pattern), &TREE_VEC_ELT (args, 0),
+ TREE_VEC_LENGTH (args), tmpl);
+ popclass (1);
+ }
/* Convince duplicate_decls to use the DECL_ARGUMENTS from the new decl. */
if (TREE_CODE (d) == FUNCTION_DECL)
else if (TREE_CODE (d) == FUNCTION_DECL)
{
tree t = DECL_SAVED_TREE (pattern);
- int line = lineno;
- char *file = input_filename;
-
- lineno = DECL_SOURCE_LINE (d);
- input_filename = DECL_SOURCE_FILE (d);
start_function (NULL_TREE, d, NULL_TREE, 1);
store_parm_decls ();
TREE_VEC_LENGTH (args), tmpl);
finish_function (lineno, 0, nested);
-
- lineno = line;
- input_filename = file;
}
+ lineno = line;
+ input_filename = file;
+
pop_from_top_level ();
pop_tinst_level ();
#undef NULL
#define NULL 0
+#ifndef INT_TYPE_SIZE
+#define INT_TYPE_SIZE BITS_PER_WORD
+#endif
+
extern tree define_function ();
extern tree build_t_desc_overload ();
extern struct obstack *permanent_obstack;
return build (PLUS_EXPR, type, exp,
convert (ptrdiff_type_node, offset));
}
+
+/* Build a call to a generic entry point taking and returning void. */
+
+static tree
+call_void_fn (name)
+ char *name;
+{
+ tree d = get_identifier (name);
+ tree type;
+
+ if (IDENTIFIER_GLOBAL_VALUE (d))
+ d = IDENTIFIER_GLOBAL_VALUE (d);
+ else
+ {
+ push_obstacks (&permanent_obstack, &permanent_obstack);
+
+ type = build_function_type (void_type_node, void_list_node);
+ d = build_lang_decl (FUNCTION_DECL, d, type);
+ DECL_EXTERNAL (d) = 1;
+ TREE_PUBLIC (d) = 1;
+ DECL_ARTIFICIAL (d) = 1;
+ pushdecl_top_level (d);
+ make_function_rtl (d);
+ assemble_external (d);
+
+ pop_obstacks ();
+ }
+
+ return build_call (d, void_type_node, NULL_TREE);
+}
+
+/* Get a bad_cast node for the program to throw...
+
+ See libstdc++/exception.cc for __throw_bad_cast */
+
+static tree
+throw_bad_cast ()
+{
+ return call_void_fn ("__throw_bad_cast");
+}
+
+static tree
+throw_bad_typeid ()
+{
+ return call_void_fn ("__throw_bad_typeid");
+}
\f
-/* Return the type_info node associated with the expression EXP. If EXP is
- a reference to a polymorphic class, return the dynamic type; otherwise
- return the static type of the expression. */
+/* Return the type_info function associated with the expression EXP. If
+ EXP is a reference to a polymorphic class, return the dynamic type;
+ otherwise return the static type of the expression. */
tree
-build_typeid (exp)
+get_tinfo_fn_dynamic (exp)
tree exp;
{
tree type;
type = TREE_TYPE (exp);
- /* Strip top-level cv-qualifiers. */
- type = TYPE_MAIN_VARIANT (type);
-
- /* if b is an instance of B, typeid(b) == typeid(B). Do this before
- reference trickiness. */
- if (TREE_CODE (exp) == VAR_DECL && TREE_CODE (type) == RECORD_TYPE)
- return get_typeid (type);
-
/* peel back references, so they match. */
if (TREE_CODE (type) == REFERENCE_TYPE)
type = TREE_TYPE (type);
/* Peel off cv qualifiers. */
type = TYPE_MAIN_VARIANT (type);
- /* Apply trivial conversion T -> T& for dereferenced ptrs. */
- if (TREE_CODE (type) == RECORD_TYPE)
- type = build_reference_type (type);
-
/* If exp is a reference to polymorphic type, get the real type_info. */
- if (TREE_CODE (type) == REFERENCE_TYPE && TYPE_VIRTUAL_P (TREE_TYPE (type)))
+ if (TYPE_VIRTUAL_P (type) && ! resolves_to_fixed_type_p (exp, 0))
{
/* build reference to type_info from vtable. */
tree t;
warning ("taking dynamic typeid of object without -frtti");
/* If we don't have rtti stuff, get to a sub-object that does. */
- if (!CLASSTYPE_VFIELDS (TREE_TYPE (type)))
+ if (! CLASSTYPE_VFIELDS (type))
{
exp = build_unary_op (ADDR_EXPR, exp, 0);
exp = build_headof_sub (exp);
else
t = build_vfn_ref ((tree *) 0, exp, integer_zero_node);
TREE_TYPE (t) = build_pointer_type (tinfo_fn_type);
-
- t = build (CALL_EXPR, TREE_TYPE (tinfo_fn_type), t, NULL_TREE, NULL_TREE);
- TREE_SIDE_EFFECTS (t) = 1;
- return convert_from_reference (t);
+ return t;
}
/* otherwise return the type_info for the static type of the expr. */
- return get_typeid (type);
+ return get_tinfo_fn (TYPE_MAIN_VARIANT (type));
+}
+
+tree
+build_typeid (exp)
+ tree exp;
+{
+ exp = get_tinfo_fn_dynamic (exp);
+ exp = build_call (exp, TREE_TYPE (tinfo_fn_type), NULL_TREE);
+ return convert_from_reference (exp);
+}
+
+tree
+build_x_typeid (exp)
+ tree exp;
+{
+ tree cond = NULL_TREE;
+ tree type = TREE_TYPE (tinfo_fn_type);
+ int nonnull;
+
+ if (processing_template_decl)
+ return build_min_nt (TYPEID_EXPR, exp);
+
+ if (TREE_CODE (exp) == INDIRECT_REF
+ && TREE_CODE (TREE_TYPE (TREE_OPERAND (exp, 0))) == POINTER_TYPE
+ && TYPE_VIRTUAL_P (TREE_TYPE (exp))
+ && ! resolves_to_fixed_type_p (exp, &nonnull)
+ && ! nonnull)
+ {
+ exp = stabilize_reference (exp);
+ cond = convert (boolean_type_node, TREE_OPERAND (exp, 0));
+ }
+
+ exp = get_tinfo_fn_dynamic (exp);
+ exp = build_call (exp, type, NULL_TREE);
+
+ if (cond)
+ {
+ tree bad = throw_bad_typeid ();
+
+ bad = build_compound_expr
+ (tree_cons (NULL_TREE, bad, build_tree_list
+ (NULL_TREE, convert (type, integer_zero_node))));
+ exp = build (COND_EXPR, type, cond, exp, bad);
+ }
+
+ return convert_from_reference (exp);
}
tree
If our struct layout or the type_info classes are changed, this will
need to be modified. */
if (TYPE_VOLATILE (type) || TYPE_READONLY (type))
- size = 4 * POINTER_SIZE;
+ size = 3 * POINTER_SIZE + INT_TYPE_SIZE;
else if (TREE_CODE (type) == POINTER_TYPE
&& ! (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE
|| TREE_CODE (TREE_TYPE (type)) == METHOD_TYPE))
(TREE_VEC_ELT (TYPE_BINFO_BASETYPES (type), 0))))
size = 3 * POINTER_SIZE;
else
- size = 4 * POINTER_SIZE;
+ size = 3 * POINTER_SIZE + INT_TYPE_SIZE;
}
else
size = 2 * POINTER_SIZE;
get_typeid_1 (type)
tree type;
{
- tree t = build (CALL_EXPR, TREE_TYPE (tinfo_fn_type),
- default_conversion (get_tinfo_fn (type)), NULL_TREE, NULL_TREE);
- TREE_SIDE_EFFECTS (t) = 1;
+ tree t = build_call
+ (get_tinfo_fn (type), TREE_TYPE (tinfo_fn_type), NULL_TREE);
return convert_from_reference (t);
}
return get_typeid_1 (type);
}
-/* Get a bad_cast node for the program to throw...
-
- See libstdc++/exception.cc for __throw_bad_cast */
-
-static tree
-throw_bad_cast ()
-{
- tree d = get_identifier ("__throw_bad_cast");
- tree type;
-
- if (IDENTIFIER_GLOBAL_VALUE (d))
- return IDENTIFIER_GLOBAL_VALUE (d);
-
- push_obstacks (&permanent_obstack, &permanent_obstack);
-
- type = build_function_type (void_type_node, void_list_node);
- d = build_lang_decl (FUNCTION_DECL, d, type);
- DECL_EXTERNAL (d) = 1;
- TREE_PUBLIC (d) = 1;
- DECL_ARTIFICIAL (d) = 1;
- pushdecl_top_level (d);
- make_function_rtl (d);
- assemble_external (d);
-
- pop_obstacks ();
-
- d = build (CALL_EXPR, void_type_node, default_conversion (d), NULL_TREE, NULL_TREE);
- TREE_SIDE_EFFECTS (d) = 1;
- return d;
-}
-
/* Check whether TEST is null before returning RESULT. If TEST is used in
RESULT, it must have previously had a save_expr applied to it. */
if (type == error_mark_node || expr == error_mark_node)
return error_mark_node;
- if (current_template_parms)
+ if (processing_template_decl)
{
tree t = build_min (DYNAMIC_CAST_EXPR, type, expr);
return t;
expr2 = build_headof (expr1);
if (ec == POINTER_TYPE)
- td1 = build_typeid (build_indirect_ref (expr, NULL_PTR));
+ td1 = get_tinfo_fn_dynamic (build_indirect_ref (expr, NULL_PTR));
else
- td1 = build_typeid (expr);
+ td1 = get_tinfo_fn_dynamic (expr);
+ td1 = decay_conversion (td1);
- td2 = get_typeid (TREE_TYPE (type));
- td3 = get_typeid (TREE_TYPE (exprtype));
+ td2 = decay_conversion
+ (get_tinfo_fn (TYPE_MAIN_VARIANT (TREE_TYPE (type))));
+ td3 = decay_conversion
+ (get_tinfo_fn (TYPE_MAIN_VARIANT (TREE_TYPE (exprtype))));
elems = tree_cons
- (NULL_TREE, TREE_OPERAND (td1, 0), tree_cons
- (NULL_TREE, TREE_OPERAND (td2, 0), tree_cons
+ (NULL_TREE, td1, tree_cons
+ (NULL_TREE, td2, tree_cons
(NULL_TREE, build_int_2 (1, 0), tree_cons
(NULL_TREE, expr2, tree_cons
- (NULL_TREE, TREE_OPERAND (td3, 0), tree_cons
+ (NULL_TREE, td3, tree_cons
(NULL_TREE, expr1, NULL_TREE))))));
dcast_fn = get_identifier ("__dynamic_cast");
tree tmp;
push_obstacks (&permanent_obstack, &permanent_obstack);
- tmp = build_reference_type
- (build_type_variant (type_info_type_node, 1, 0));
tmp = tree_cons
- (NULL_TREE, tmp, tree_cons
- (NULL_TREE, tmp, tree_cons
+ (NULL_TREE, TREE_TYPE (td1), tree_cons
+ (NULL_TREE, TREE_TYPE (td1), tree_cons
(NULL_TREE, integer_type_node, tree_cons
(NULL_TREE, ptr_type_node, tree_cons
- (NULL_TREE, tmp, tree_cons
+ (NULL_TREE, TREE_TYPE (td1), tree_cons
(NULL_TREE, ptr_type_node, void_list_node))))));
tmp = build_function_type (ptr_type_node, tmp);
dcast_fn = build_lang_decl (FUNCTION_DECL, dcast_fn, tmp);
pop_obstacks ();
}
- result = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (dcast_fn)),
- decay_conversion (dcast_fn), elems, NULL_TREE);
- TREE_SIDE_EFFECTS (result) = 1;
+ result = build_call
+ (dcast_fn, TREE_TYPE (TREE_TYPE (dcast_fn)), elems);
if (tc == REFERENCE_TYPE)
{
expr1 = throw_bad_cast ();
- expr1 = build_compound_expr (tree_cons (NULL_TREE, expr1,
- build_tree_list (NULL_TREE, convert (type, integer_zero_node))));
+ expr1 = build_compound_expr
+ (tree_cons (NULL_TREE, expr1,
+ build_tree_list (NULL_TREE, convert
+ (type, integer_zero_node))));
TREE_TYPE (expr1) = type;
result = save_expr (result);
return build (COND_EXPR, type, result, result, expr1);
pop_obstacks ();
}
- fn = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
- decay_conversion (fn), elems, NULL_TREE);
- TREE_SIDE_EFFECTS (fn) = 1;
+ fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
(FIELD_DECL, NULL_TREE,
build_pointer_type (build_type_variant (type_info_type_node, 1, 0)));
fields [1] = build_lang_field_decl
- (FIELD_DECL, NULL_TREE, sizetype);
+ (FIELD_DECL, NULL_TREE, unsigned_intSI_type_node);
DECL_BIT_FIELD (fields[1]) = 1;
DECL_FIELD_SIZE (fields[1]) = 29;
pop_obstacks ();
}
- fn = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
- decay_conversion (fn), elems, NULL_TREE);
- TREE_SIDE_EFFECTS (fn) = 1;
+ fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
pop_obstacks ();
}
- fn = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
- decay_conversion (fn), elems, NULL_TREE);
- TREE_SIDE_EFFECTS (fn) = 1;
+ fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
pop_obstacks ();
}
- fn = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
- decay_conversion (fn), elems, NULL_TREE);
- TREE_SIDE_EFFECTS (fn) = 1;
+ fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
pop_obstacks ();
}
- fn = build (CALL_EXPR, TREE_TYPE (TREE_TYPE (fn)),
- decay_conversion (fn), elems, NULL_TREE);
- TREE_SIDE_EFFECTS (fn) = 1;
+ fn = build_call (fn, TREE_TYPE (TREE_TYPE (fn)), elems);
expand_expr_stmt (fn);
}
tmp = build_binary_op (EQ_EXPR, tmp, integer_zero_node, 1);
expand_start_cond (tmp, 0);
- if (TYPE_VOLATILE (type) || TYPE_READONLY (type))
- expand_attr_desc (tdecl, type);
+ if (TREE_CODE (type) == FUNCTION_TYPE)
+ expand_generic_desc (tdecl, type, "__rtti_func");
else if (TREE_CODE (type) == ARRAY_TYPE)
expand_generic_desc (tdecl, type, "__rtti_array");
+ else if (TYPE_VOLATILE (type) || TYPE_READONLY (type))
+ expand_attr_desc (tdecl, type);
else if (TREE_CODE (type) == POINTER_TYPE)
{
if (TREE_CODE (TREE_TYPE (type)) == OFFSET_TYPE)
}
else if (TREE_CODE (type) == ENUMERAL_TYPE)
expand_generic_desc (tdecl, type, "__rtti_user");
- else if (TREE_CODE (type) == FUNCTION_TYPE)
- expand_generic_desc (tdecl, type, "__rtti_func");
else
my_friendly_abort (252);
--- /dev/null
+// Methods for type_info for -*- C++ -*- Run Time Type Identification.
+// Copyright (C) 1994, 1996 Free Software Foundation
+
+// This file is part of GNU CC.
+
+// GNU CC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// GNU CC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GNU CC; see the file COPYING. If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+// As a special exception, if you link this library with other files,
+// some of which are compiled with GCC, to produce an executable,
+// this library does not by itself cause the resulting executable
+// to be covered by the GNU General Public License.
+// This exception does not however invalidate any other reasons why
+// the executable file might be covered by the GNU General Public License.
+
+#include <stddef.h>
+#include "tinfo.h"
+#include "new" // for placement new
+
+// This file contains the minimal working set necessary to link with code
+// that uses virtual functions and -frtti but does not actually use RTTI
+// functionality.
+
+type_info::
+~type_info ()
+{ }
+
+extern "C" void
+__rtti_class (void *addr, const char *name,
+ const __class_type_info::base_info *bl, size_t bn)
+{ new (addr) __class_type_info (name, bl, bn); }
+
+extern "C" void
+__rtti_si (void *addr, const char *n, const type_info *ti)
+{
+ new (addr) __si_type_info
+ (n, static_cast <const __user_type_info &> (*ti));
+}
+
+extern "C" void
+__rtti_user (void *addr, const char *name)
+{ new (addr) __user_type_info (name); }
+
+// dynamic_cast helper methods.
+// Returns a pointer to the desired sub-object or 0.
+
+void * __user_type_info::
+dcast (const type_info& to, int, void *addr, const type_info *, void *) const
+{ return (*this == to) ? addr : 0; }
+
+void * __si_type_info::
+dcast (const type_info& to, int require_public, void *addr,
+ const type_info *sub, void *subptr) const
+{
+ if (*this == to)
+ return addr;
+ return base.dcast (to, require_public, addr, sub, subptr);
+}
+
+void* __class_type_info::
+dcast (const type_info& desired, int is_public, void *objptr,
+ const type_info *sub, void *subptr) const
+{
+ if (*this == desired)
+ return objptr;
+
+ void *match_found = 0;
+ for (int i = 0; i < n_bases; i++)
+ {
+ if (is_public && base_list[i].access != PUBLIC)
+ continue;
+
+ void *p = (char *)objptr + base_list[i].offset;
+ if (base_list[i].is_virtual)
+ p = *(void **)p;
+ p = base_list[i].base->dcast (desired, is_public, p, sub, subptr);
+ if (p)
+ {
+ if (match_found == 0)
+ match_found = p;
+ else if (match_found != p)
+ {
+ if (sub)
+ {
+ // Perhaps we're downcasting from *sub to desired; see if
+ // subptr is a subobject of exactly one of {match_found,p}.
+
+ const __user_type_info &d =
+ static_cast <const __user_type_info &> (desired);
+
+ void *os = d.dcast (*sub, 1, match_found);
+ void *ns = d.dcast (*sub, 1, p);
+
+ if (os == ns)
+ /* ambiguous -- subptr is a virtual base */;
+ else if (os == subptr)
+ continue;
+ else if (ns == subptr)
+ {
+ match_found = p;
+ continue;
+ }
+ }
+
+ // base found at two different pointers,
+ // conversion is not unique
+ return 0;
+ }
+ }
+ }
+
+ return match_found;
+}
--- /dev/null
+// Methods for type_info for -*- C++ -*- Run Time Type Identification.
+// Copyright (C) 1994, 1996 Free Software Foundation
+
+// This file is part of GNU CC.
+
+// GNU CC is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License as published by
+// the Free Software Foundation; either version 2, or (at your option)
+// any later version.
+
+// GNU CC is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License
+// along with GNU CC; see the file COPYING. If not, write to
+// the Free Software Foundation, 59 Temple Place - Suite 330,
+// Boston, MA 02111-1307, USA.
+
+// As a special exception, if you link this library with other files,
+// some of which are compiled with GCC, to produce an executable,
+// this library does not by itself cause the resulting executable
+// to be covered by the GNU General Public License.
+// This exception does not however invalidate any other reasons why
+// the executable file might be covered by the GNU General Public License.
+
+#include <stddef.h>
+#include "tinfo.h"
+#include "new" // for placement new
+
+// service function for comparing types by name.
+
+static inline int
+fast_compare (const char *n1, const char *n2) {
+ int c;
+ if (n1 == n2) return 0;
+ if (n1 == 0) return *n2;
+ else if (n2 == 0) return *n1;
+
+ c = (int)*n1++ - (int)*n2++;
+ return c == 0 ? strcmp (n1, n2) : c;
+};
+
+bool
+type_info::before (const type_info &arg)
+{
+ return fast_compare (name (), arg.name ()) < 0;
+}
+
+#ifdef _WIN32
+bool type_info::
+operator== (const type_info& arg) const
+{
+ return fast_compare (name (), arg.name ()) == 0;
+}
+
+bool type_info::
+operator!= (const type_info& arg) const
+{
+ return fast_compare (name (), arg.name ()) != 0;
+}
+#endif
+
+// type info for pointer type.
+
+struct __pointer_type_info : public type_info {
+ const type_info& type;
+
+ __pointer_type_info (const char *n, const type_info& ti)
+ : type_info (n), type (ti) {}
+};
+
+// type info for attributes
+
+struct __attr_type_info : public type_info {
+ enum cv { NONE = 0, CONST = 1, VOLATILE = 2, CONSTVOL = 1 | 2 };
+
+ const type_info& type;
+ cv attr;
+
+ __attr_type_info (const char *n, cv a, const type_info& t)
+ : type_info (n), type (t), attr (a) {}
+};
+
+// type_info for builtin type
+
+struct __builtin_type_info : public type_info {
+ __builtin_type_info (const char *n): type_info (n) {}
+};
+
+// type info for function.
+
+struct __func_type_info : public type_info {
+ __func_type_info (const char *n) : type_info (n) {}
+};
+
+// type info for pointer to member function.
+
+struct __ptmf_type_info : public type_info {
+ __ptmf_type_info (const char *n) : type_info (n) {}
+};
+
+// type info for pointer to data member.
+
+struct __ptmd_type_info : public type_info {
+ __ptmd_type_info (const char *n): type_info (n) {}
+};
+
+// type info for array.
+
+struct __array_type_info : public type_info {
+ __array_type_info (const char *n): type_info (n) {}
+};
+
+// Entry points for the compiler.
+
+/* Low level match routine used by compiler to match types of catch
+ variables and thrown objects. */
+
+extern "C" void*
+__throw_type_match_rtti (void *catch_type_r, void *throw_type_r, void *objptr)
+{
+ const type_info &catch_type = *(const type_info *)catch_type_r;
+ const type_info &throw_type = *(const type_info *)throw_type_r;
+
+ if (catch_type == throw_type)
+ return objptr;
+
+#if 0
+ printf ("We want to match a %s against a %s!\n",
+ throw_type.name (), catch_type.name ());
+#endif
+
+ void *new_objptr = 0;
+
+ if (const __user_type_info *p
+ = dynamic_cast <const __user_type_info *> (&throw_type))
+ {
+ /* The 1 skips conversions to private bases. */
+ new_objptr = p->dcast (catch_type, 1, objptr);
+ }
+ else if (const __pointer_type_info *fr =
+ dynamic_cast <const __pointer_type_info *> (&throw_type))
+ {
+ const __pointer_type_info *to =
+ dynamic_cast <const __pointer_type_info *> (&catch_type);
+
+ if (! to)
+ goto fail;
+
+ const type_info *subfr = &fr->type, *subto = &to->type;
+ __attr_type_info::cv cvfrom, cvto;
+
+ if (const __attr_type_info *at
+ = dynamic_cast <const __attr_type_info *> (subfr))
+ {
+ cvfrom = at->attr;
+ subfr = &at->type;
+ }
+ else
+ cvfrom = __attr_type_info::NONE;
+
+ if (const __attr_type_info *at
+ = dynamic_cast <const __attr_type_info *> (subto))
+ {
+ cvto = at->attr;
+ subto = &at->type;
+ }
+ else
+ cvto = __attr_type_info::NONE;
+
+ if (((cvfrom & __attr_type_info::CONST)
+ > (cvto & __attr_type_info::CONST))
+ || ((cvfrom & __attr_type_info::VOLATILE)
+ > (cvto & __attr_type_info::VOLATILE)))
+ goto fail;
+
+ if (*subto == *subfr)
+ new_objptr = objptr;
+ else if (*subto == typeid (void)
+ && dynamic_cast <const __func_type_info *> (subfr) == 0)
+ new_objptr = objptr;
+ else if (const __user_type_info *p
+ = dynamic_cast <const __user_type_info *> (subfr))
+ {
+ /* The 1 skips conversions to private bases. */
+ new_objptr = p->dcast (*subto, 1, objptr);
+ }
+ else if (const __pointer_type_info *pfr
+ = dynamic_cast <const __pointer_type_info *> (subfr))
+ {
+ // Multi-level pointer conversion.
+
+ const __pointer_type_info *pto
+ = dynamic_cast <const __pointer_type_info *> (subto);
+
+ if (! pto)
+ goto fail;
+
+ bool constp = (cvto & __attr_type_info::CONST);
+ for (subto = &pto->type, subfr = &pfr->type; ;
+ subto = &pto->type, subfr = &pfr->type)
+ {
+ if (const __attr_type_info *at
+ = dynamic_cast <const __attr_type_info *> (subfr))
+ {
+ cvfrom = at->attr;
+ subfr = &at->type;
+ }
+ else
+ cvfrom = __attr_type_info::NONE;
+
+ if (const __attr_type_info *at
+ = dynamic_cast <const __attr_type_info *> (subto))
+ {
+ cvto = at->attr;
+ subto = &at->type;
+ }
+ else
+ cvto = __attr_type_info::NONE;
+
+ if (((cvfrom & __attr_type_info::CONST)
+ > (cvto & __attr_type_info::CONST))
+ || ((cvfrom & __attr_type_info::VOLATILE)
+ > (cvto & __attr_type_info::VOLATILE)))
+ goto fail;
+
+ if (! constp
+ && (((cvfrom & __attr_type_info::CONST)
+ < (cvto & __attr_type_info::CONST))
+ || ((cvfrom & __attr_type_info::VOLATILE)
+ < (cvto & __attr_type_info::VOLATILE))))
+ goto fail;
+
+ if (*subto == *subfr)
+ {
+ new_objptr = objptr;
+ break;
+ }
+
+ pto = dynamic_cast <const __pointer_type_info *> (subto);
+ pfr = dynamic_cast <const __pointer_type_info *> (subfr);
+ if (! pto || ! pfr)
+ goto fail;
+
+ if (! (cvto & __attr_type_info::CONST))
+ constp = false;
+ }
+ }
+ }
+ fail:
+
+#if 0
+ if (new_objptr)
+ printf ("It converts, delta is %d\n", new_objptr-objptr);
+#endif
+ return new_objptr;
+}
+
+extern "C" void
+__rtti_ptr (void *addr, const char *n, const type_info *ti)
+{ new (addr) __pointer_type_info (n, *ti); }
+
+extern "C" void
+__rtti_attr (void *addr, const char *n, int attrval, const type_info *ti)
+{
+ new (addr) __attr_type_info
+ (n, static_cast <__attr_type_info::cv> (attrval), *ti);
+}
+
+extern "C" void
+__rtti_func (void *addr, const char *name)
+{ new (addr) __func_type_info (name); }
+
+extern "C" void
+__rtti_ptmf (void *addr, const char *name)
+{ new (addr) __ptmf_type_info (name); }
+
+extern "C" void
+__rtti_ptmd (void *addr, const char *name)
+{ new (addr) __ptmd_type_info (name); }
+
+extern "C" void
+__rtti_array (void *addr, const char *name)
+{ new (addr) __array_type_info (name); }
+
+extern "C" void *
+__dynamic_cast (const type_info& (*from)(void), const type_info& (*to)(void),
+ int require_public, void *address,
+ const type_info & (*sub)(void), void *subptr)
+{
+ return static_cast <const __user_type_info &> (from ()).dcast
+ (to (), require_public, address, &(sub ()), subptr);
+}
+
+// type_info nodes and functions for the builtin types. The mangling here
+// must match the mangling in gcc/cp/rtti.c.
+
+#define BUILTIN(mangled) \
+unsigned char __ti##mangled [sizeof (__builtin_type_info)] \
+ __attribute__ ((aligned (__alignof__ (void *)))); \
+extern "C" const type_info &__tf##mangled (void) { \
+ if ((*(void **) __ti##mangled) == 0) \
+ new (__ti##mangled) __builtin_type_info (#mangled); \
+ return *(type_info *)__ti##mangled; \
+}
+
+BUILTIN (v); BUILTIN (x); BUILTIN (l); BUILTIN (i); BUILTIN (s); BUILTIN (b);
+BUILTIN (c); BUILTIN (w); BUILTIN (r); BUILTIN (d); BUILTIN (f);
+BUILTIN (Ui); BUILTIN (Ul); BUILTIN (Ux); BUILTIN (Us); BUILTIN (Uc);
extern struct obstack *current_obstack;
extern struct obstack permanent_obstack, class_obstack;
extern struct obstack *saveable_obstack;
+extern struct obstack *expression_obstack;
/* Here is how primitive or already-canonicalized types' hash
codes are made. MUST BE CONSISTENT WITH tree.c !!! */
saveable_obstack = &permanent_obstack;
}
- if (current_template_parms)
+ if (processing_template_decl)
{
t = make_node (ARRAY_TYPE);
TREE_TYPE (t) = elt_type;
mapcar (TYPE_ARG_TYPES (t), func));
return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
case ARRAY_TYPE:
- tmp = build_array_type (mapcar (TREE_TYPE (t), func),
- mapcar (TYPE_DOMAIN (t), func));
+ tmp = build_cplus_array_type (mapcar (TREE_TYPE (t), func),
+ mapcar (TYPE_DOMAIN (t), func));
return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
case INTEGER_TYPE:
tmp = build_index_type (mapcar (TYPE_MAX_VALUE (t), func));
mapcar (TREE_CHAIN (TYPE_ARG_TYPES (t)), func));
return cp_build_type_variant (tmp, TYPE_READONLY (t), TYPE_VOLATILE (t));
+ case CONSTRUCTOR:
+ t = copy_node (t);
+ CONSTRUCTOR_ELTS (t) = mapcar (CONSTRUCTOR_ELTS (t), func);
+ return t;
+
case RECORD_TYPE:
if (TYPE_PTRMEMFUNC_P (t))
return build_ptrmemfunc_type
{
register struct obstack *ambient_obstack = current_obstack;
register struct obstack *ambient_saveable_obstack = saveable_obstack;
- int resume;
+ register struct obstack *ambient_expression_obstack = expression_obstack;
if (t == NULL_TREE || TREE_PERMANENT (t))
return t;
saveable_obstack = &permanent_obstack;
current_obstack = saveable_obstack;
- resume = suspend_momentary ();
+ expression_obstack = saveable_obstack;
t = mapcar (t, perm_manip);
- resume_momentary (resume);
current_obstack = ambient_obstack;
saveable_obstack = ambient_saveable_obstack;
+ expression_obstack = ambient_expression_obstack;
return t;
}
{
tree type;
- if (current_template_parms)
+ if (processing_template_decl)
return value;
type = TREE_TYPE (value);
else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
{
tree t = complete_type (TREE_TYPE (type));
- if (TYPE_SIZE (t) != NULL_TREE
- && current_template_parms == NULL_TREE)
+ if (TYPE_SIZE (t) != NULL_TREE && ! processing_template_decl)
layout_type (type);
TYPE_NEEDS_CONSTRUCTING (type)
= TYPE_NEEDS_CONSTRUCTING (TYPE_MAIN_VARIANT (t));
enum tree_code code = TREE_CODE (type);
tree t;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min (SIZEOF_EXPR, sizetype, type);
if (code == FUNCTION_TYPE)
expr_sizeof (e)
tree e;
{
- if (current_template_parms)
+ if (processing_template_decl)
return build_min (SIZEOF_EXPR, sizetype, e);
if (TREE_CODE (e) == COMPONENT_REF
{
tree binfo = binfo_or_else (basetype, dtype);
if (binfo)
- return build_component_ref (build_scoped_ref (datum, basetype),
- field, binfo, 1);
+ return build_x_component_ref (build_scoped_ref (datum, basetype),
+ field, binfo, 1);
}
return error_mark_node;
}
register tree field = NULL;
register tree ref;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (COMPONENT_REF, datum, component);
/* If DATUM is a COMPOUND_EXPR or COND_EXPR, move our reference
return ref;
}
+
+/* Variant of build_component_ref for use in expressions, which should
+ never have REFERENCE_TYPE. */
+
+tree
+build_x_component_ref (datum, component, basetype_path, protect)
+ tree datum, component, basetype_path;
+ int protect;
+{
+ tree t = build_component_ref (datum, component, basetype_path, protect);
+
+ if (! processing_template_decl)
+ t = convert_from_reference (t);
+
+ return t;
+}
\f
/* Given an expression PTR for a pointer, return an expression
for the value pointed to.
{
tree rval;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (INDIRECT_REF, ptr);
rval = build_opfncall (INDIRECT_REF, LOOKUP_NORMAL, ptr, NULL_TREE, NULL_TREE);
if (function == error_mark_node)
return error_mark_node;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (CALL_EXPR, function, params, NULL_TREE);
type = TREE_TYPE (function);
{
tree rval;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (code, arg1, arg2);
if (flag_ansi_overloading)
enum tree_code code;
tree xarg;
{
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (code, xarg, NULL_TREE);
/* & rec, on incomplete RECORD_TYPEs is the simple opr &, not an
tree expr;
{
tree t;
- if (current_template_parms)
+ if (processing_template_decl)
return expr;
t = convert (boolean_type_node, expr);
t = fold (build1 (CLEANUP_POINT_EXPR, boolean_type_node, t));
{
tree rval = NULL_TREE;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (COND_EXPR, ifexp, op1, op2);
if (flag_ansi_overloading)
tree rest = TREE_CHAIN (list);
tree result;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (COMPOUND_EXPR, list, NULL_TREE);
if (rest == NULL_TREE)
if (TREE_CODE (expr) == OFFSET_REF)
expr = resolve_offset_ref (expr);
- if (current_template_parms)
+ if (processing_template_decl)
{
tree t = build_min (STATIC_CAST_EXPR, type, expr);
return t;
if (TREE_CODE (expr) == OFFSET_REF)
expr = resolve_offset_ref (expr);
- if (current_template_parms)
+ if (processing_template_decl)
{
tree t = build_min (REINTERPRET_CAST_EXPR, type, expr);
return t;
if (TREE_CODE (expr) == OFFSET_REF)
expr = resolve_offset_ref (expr);
- if (current_template_parms)
+ if (processing_template_decl)
{
tree t = build_min (CONST_CAST_EXPR, type, expr);
return t;
return error_mark_node;
}
- if (current_template_parms)
+ if (processing_template_decl)
{
tree t = build_min (CAST_EXPR, type,
min_tree_cons (NULL_TREE, value, NULL_TREE));
enum tree_code modifycode;
tree rhs;
{
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (MODOP_EXPR, lhs,
build_min_nt (modifycode, NULL_TREE, NULL_TREE), rhs);
return;
}
- if (current_template_parms)
+ if (processing_template_decl)
{
add_tree (build_min_nt (RETURN_STMT, retval));
return;
}
}
+ if (TYPE_PTRMEMFUNC_P (type) && TREE_CODE (init) == CONSTRUCTOR
+ && TREE_TYPE (init) == NULL_TREE)
+ cp_pedwarn ("initializer list for `%T'", type);
+
/* End of special C++ code. */
/* Digest the specified initializer into an expression. */
sorry ("initializer list for object using virtual functions");
return error_mark_node;
}
-
- if (TYPE_PTRMEMFUNC_P (type))
- cp_pedwarn ("initializer list for `%T'", type);
}
for (field = TYPE_FIELDS (type); field && tail;
if (type == error_mark_node)
return error_mark_node;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (ARROW_EXPR, rval);
if (TREE_CODE (rval) == OFFSET_REF)
tree rettype;
tree binfo;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min_nt (DOTSTAR_EXPR, datum, component);
if (TYPE_PTRMEMFUNC_P (TREE_TYPE (component)))
else
type = exp;
- if (current_template_parms)
+ if (processing_template_decl)
return build_min (CAST_EXPR, type, parms);
if (IS_SIGNATURE (type))
OSDN Git Service
