annotate gcc/cp/ChangeLog-1997 @ 131:84e7813d76e9

gcc-8.2
author mir3636
date Thu, 25 Oct 2018 07:37:49 +0900
parents 04ced10e8804
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 Mon Dec 22 11:36:27 1997 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
2
kono
parents:
diff changeset
3 * call.c (add_builtin_candidate): Add default case in enumeration
kono
parents:
diff changeset
4 switch.
kono
parents:
diff changeset
5 (build_new_op): Likewise.
kono
parents:
diff changeset
6 (convert_like): Likewise.
kono
parents:
diff changeset
7 * cvt.c (build_expr_type_conversion): Likewise.
kono
parents:
diff changeset
8 * tree.c (real_lvalue_p): Likewise.
kono
parents:
diff changeset
9 (lvalue_p): Likewise.
kono
parents:
diff changeset
10 (cp_tree_equal): Likewise.
kono
parents:
diff changeset
11 * typeck.c (comptypes): Likewise.
kono
parents:
diff changeset
12 (build_component_ref): Likewise.
kono
parents:
diff changeset
13 (build_function_call_real): Likewise.
kono
parents:
diff changeset
14 (build_binary_op_nodefault): Likewise.
kono
parents:
diff changeset
15 (build_unary_op): Likewise.
kono
parents:
diff changeset
16 (build_modify_expr): Likewise.
kono
parents:
diff changeset
17 * typeck2.c (initializer_constant_valid_p): Likewise.
kono
parents:
diff changeset
18
kono
parents:
diff changeset
19 Sun Dec 21 15:59:00 1997 Nick Clifton <nickc@cygnus.com>
kono
parents:
diff changeset
20
kono
parents:
diff changeset
21 * decl2.c (lang_decode_option): Add support for -Wunknown-pragmas.
kono
parents:
diff changeset
22
kono
parents:
diff changeset
23 Thu Dec 18 14:51:50 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
24
kono
parents:
diff changeset
25 * pt.c (coerce_template_parms): Make sure to digest_init if
kono
parents:
diff changeset
26 possible.
kono
parents:
diff changeset
27
kono
parents:
diff changeset
28 * decl.c (duplicate_decls): Make the newdecl virtual if the
kono
parents:
diff changeset
29 olddecl was, just as is done with other attributes of olddecl.
kono
parents:
diff changeset
30
kono
parents:
diff changeset
31 Thu Dec 18 14:43:19 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
32
kono
parents:
diff changeset
33 * typeck.c (unary_complex_lvalue): Ignore op0 when taking the
kono
parents:
diff changeset
34 address of an OFFSET_REF.
kono
parents:
diff changeset
35
kono
parents:
diff changeset
36 * cp-tree.def: Add AGGR_INIT_EXPR.
kono
parents:
diff changeset
37 * error.c, tree.c, typeck.c: Replace uses of NEW_EXPR with
kono
parents:
diff changeset
38 AGGR_INIT_EXPR where appropriate.
kono
parents:
diff changeset
39 * expr.c (cplus_expand_expr): Likewise. Simplify.
kono
parents:
diff changeset
40
kono
parents:
diff changeset
41 * decl2.c (finish_file): Remove call to register_exception_table.
kono
parents:
diff changeset
42
kono
parents:
diff changeset
43 Wed Dec 17 17:08:52 1997 Benjamin Kosnik <bkoz@rhino.cygnus.com>
kono
parents:
diff changeset
44
kono
parents:
diff changeset
45 * pt.c (instantiate_class_template): Don't do injection when
kono
parents:
diff changeset
46 processing_template_decl is true, as pollutes current_binding_level
kono
parents:
diff changeset
47 for base classes.
kono
parents:
diff changeset
48
kono
parents:
diff changeset
49 Wed Dec 17 21:17:39 1997 Peter Schmid <schmid@ltoi.iap.physik.tu-darmstadt.de>
kono
parents:
diff changeset
50
kono
parents:
diff changeset
51 * pt.c (maybe_fold_nontype_arg): Add prototype.
kono
parents:
diff changeset
52
kono
parents:
diff changeset
53 Tue Dec 16 10:31:20 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
54
kono
parents:
diff changeset
55 * tree.c (mapcar): Handle TRY_CATCH_EXPR et al.
kono
parents:
diff changeset
56 * error.c (dump_expr): Likewise.
kono
parents:
diff changeset
57
kono
parents:
diff changeset
58 Mon Dec 15 12:22:04 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
59
kono
parents:
diff changeset
60 * typeck.c (build_function_call_real): Remove "inline called before
kono
parents:
diff changeset
61 definition" pedwarn.
kono
parents:
diff changeset
62
kono
parents:
diff changeset
63 * pt.c (coerce_template_parms): Use maybe_fold_nontype_arg.
kono
parents:
diff changeset
64
kono
parents:
diff changeset
65 Sun Dec 14 22:34:20 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
66
kono
parents:
diff changeset
67 * cvt.c (cp_convert_to_pointer): Fix base conversion of pm's.
kono
parents:
diff changeset
68
kono
parents:
diff changeset
69 * pt.c (type_unification_real): Change __null to type void* with
kono
parents:
diff changeset
70 a warning.
kono
parents:
diff changeset
71
kono
parents:
diff changeset
72 Sun Dec 14 20:38:35 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
73
kono
parents:
diff changeset
74 * call.c (implicit_conversion): Don't call
kono
parents:
diff changeset
75 build_user_type_conversion_1 with a NULL expr, since it will
kono
parents:
diff changeset
76 crash.
kono
parents:
diff changeset
77
kono
parents:
diff changeset
78 * pt.c (unify): Don't try to unify array bounds if either array is
kono
parents:
diff changeset
79 unbounded.
kono
parents:
diff changeset
80
kono
parents:
diff changeset
81 Fri Dec 12 16:09:14 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
82
kono
parents:
diff changeset
83 * errfn.c (cp_pedwarn, cp_pedwarn_at, cp_error_at, cp_warning_at):
kono
parents:
diff changeset
84 Replace extern decls with casts.
kono
parents:
diff changeset
85
kono
parents:
diff changeset
86 * decl.c (expand_start_early_try_stmts): Don't mess with a sequence.
kono
parents:
diff changeset
87 Update last_parm_cleanup_insn.
kono
parents:
diff changeset
88 (store_after_parms): Remove.
kono
parents:
diff changeset
89 * cp-tree.h: Adjust.
kono
parents:
diff changeset
90
kono
parents:
diff changeset
91 Thu Dec 11 22:18:37 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
92
kono
parents:
diff changeset
93 * decl2.c (comdat_linkage): Also set DECL_COMDAT.
kono
parents:
diff changeset
94 (finish_file): Check DECL_COMDAT instead of weak|one_only.
kono
parents:
diff changeset
95 (import_export_vtable): Use make_decl_one_only instead of
kono
parents:
diff changeset
96 comdat_linkage for win32 tweak.
kono
parents:
diff changeset
97 (import_export_decl): Likewise.
kono
parents:
diff changeset
98 * pt.c (mark_decl_instantiated): Likewise.
kono
parents:
diff changeset
99
kono
parents:
diff changeset
100 * decl2.c (finish_file): Lose handling of templates in pending_statics.
kono
parents:
diff changeset
101
kono
parents:
diff changeset
102 Thu Dec 11 21:12:09 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
103
kono
parents:
diff changeset
104 * decl2.c (finish_file): Lose call to expand_builtin_throw.
kono
parents:
diff changeset
105 * except.c (expand_builtin_throw): Remove.
kono
parents:
diff changeset
106 * cp-tree.h: Remove ptr_ptr_type_node.
kono
parents:
diff changeset
107 * decl.c: Likewise.
kono
parents:
diff changeset
108
kono
parents:
diff changeset
109 Thu Dec 11 20:43:33 1997 Teemu Torma <tot@trema.com>
kono
parents:
diff changeset
110
kono
parents:
diff changeset
111 * decl.c (ptr_ptr_type_node): Define.
kono
parents:
diff changeset
112 (init_decl_processing): Initialize it.
kono
parents:
diff changeset
113 * cp-tree.h: Declare it.
kono
parents:
diff changeset
114 * exception.cc (__cp_exception_info): Use __get_eh_info.
kono
parents:
diff changeset
115 (__cp_push_exception): Likewise.
kono
parents:
diff changeset
116 (__cp_pop_exception): Likewise.
kono
parents:
diff changeset
117
kono
parents:
diff changeset
118 From Scott Snyder <snyder@d0sgif.fnal.gov>:
kono
parents:
diff changeset
119 * except.c (expand_builtin_throw): Use get_saved_pc_ref instead of
kono
parents:
diff changeset
120 saved_pc.
kono
parents:
diff changeset
121 (init_exception_processing): Removed saved_pc initialization.
kono
parents:
diff changeset
122
kono
parents:
diff changeset
123 Wed Dec 10 11:04:45 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
124
kono
parents:
diff changeset
125 * pt.c (instantiate_decl): Defer all templates but inline functions.
kono
parents:
diff changeset
126
kono
parents:
diff changeset
127 Mon Dec 8 23:17:13 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
128
kono
parents:
diff changeset
129 * init.c (expand_vec_init): Don't fold a list of parameters.
kono
parents:
diff changeset
130
kono
parents:
diff changeset
131 * decl.c (copy_args_p): Handle copy elision for types with virtual
kono
parents:
diff changeset
132 bases.
kono
parents:
diff changeset
133 * call.c (build_over_call): Likewise.
kono
parents:
diff changeset
134
kono
parents:
diff changeset
135 Sun Dec 7 22:38:12 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
136
kono
parents:
diff changeset
137 * pt.c (lookup_template_function): Copy the template arguments,
kono
parents:
diff changeset
138 not just the list containing them, to the permanent obstack.
kono
parents:
diff changeset
139
kono
parents:
diff changeset
140 Sun Dec 7 15:53:06 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
141
kono
parents:
diff changeset
142 * except.c (expand_start_catch_block): suspend_momentary for the
kono
parents:
diff changeset
143 terminate handler.
kono
parents:
diff changeset
144
kono
parents:
diff changeset
145 * error.c (dump_decl): Handle LOOKUP_EXPR.
kono
parents:
diff changeset
146
kono
parents:
diff changeset
147 Sun Dec 7 15:45:07 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
148
kono
parents:
diff changeset
149 * rtti.c (build_dynamic_cast): Copy the cast-to type to the
kono
parents:
diff changeset
150 permanent obstack if we are processing a template decl.
kono
parents:
diff changeset
151 * typeck.c (build_static_cast): Likewise.
kono
parents:
diff changeset
152 (build_const_cast): Likewise.
kono
parents:
diff changeset
153 (build_reinterpret_cast): Likewise.
kono
parents:
diff changeset
154
kono
parents:
diff changeset
155 * pt.c (coerce_template_parms): Coerce some expressions, even
kono
parents:
diff changeset
156 when processing_template_decl.
kono
parents:
diff changeset
157
kono
parents:
diff changeset
158 Sun Dec 7 01:46:33 1997 Bruno Haible <bruno@linuix.mathematik.uni-karlsruhe.de>
kono
parents:
diff changeset
159
kono
parents:
diff changeset
160 * typeck.c (build_binary_op_nodefault, pointer_diff): Symmetric
kono
parents:
diff changeset
161 handling of pointer difference expressions.
kono
parents:
diff changeset
162
kono
parents:
diff changeset
163 * typeck.c (comp_target_types): Comparison of function/method types
kono
parents:
diff changeset
164 is independent of nptrs.
kono
parents:
diff changeset
165
kono
parents:
diff changeset
166 Sun Dec 7 01:40:27 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
167
kono
parents:
diff changeset
168 * pt.c (tsubst): Avoid creating pointer to reference and
kono
parents:
diff changeset
169 reference to reference types.
kono
parents:
diff changeset
170
kono
parents:
diff changeset
171 Sat Dec 6 01:29:37 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
172
kono
parents:
diff changeset
173 * parse.y (do_id): New nonterminal.
kono
parents:
diff changeset
174 (template_id): Use it.
kono
parents:
diff changeset
175
kono
parents:
diff changeset
176 Fri Dec 5 01:17:34 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
177
kono
parents:
diff changeset
178 * parse.y (template_id): do_identifier for PFUNCNAMEs, too.
kono
parents:
diff changeset
179 * spew.c (yylex): Don't do_identifier here.
kono
parents:
diff changeset
180 * decl2.c (build_expr_from_tree): Revert last change.
kono
parents:
diff changeset
181
kono
parents:
diff changeset
182 * decl2.c (build_expr_from_tree): Expand the name for a method call.
kono
parents:
diff changeset
183 * parse.y (object_template_id): Don't try to take the DECL_NAME.
kono
parents:
diff changeset
184
kono
parents:
diff changeset
185 Wed Dec 3 20:02:39 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
186
kono
parents:
diff changeset
187 * init.c (build_new): Use a TARGET_EXPR instead of SAVE_EXPR for
kono
parents:
diff changeset
188 alloc_expr.
kono
parents:
diff changeset
189 * call.c (build_op_delete_call): Adjust.
kono
parents:
diff changeset
190
kono
parents:
diff changeset
191 * except.c (expand_end_catch_block): Lose rethrow region.
kono
parents:
diff changeset
192 (expand_start_catch_block): Likewise.
kono
parents:
diff changeset
193 (expand_end_catch_block): Don't expand_leftover_cleanups.
kono
parents:
diff changeset
194
kono
parents:
diff changeset
195 Wed Dec 3 13:24:04 1997 Benjamin Kosnik <bkoz@rhino.cygnus.com>
kono
parents:
diff changeset
196
kono
parents:
diff changeset
197 * pt.c (tsubst): Remove tree_cons call (places redundant info into
kono
parents:
diff changeset
198 DECL_TEMPLATE_INSTANTIATION).
kono
parents:
diff changeset
199
kono
parents:
diff changeset
200 Wed Dec 3 11:44:52 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
201
kono
parents:
diff changeset
202 * tree.c (is_overloaded_fn): Handle getting a fn template.
kono
parents:
diff changeset
203 (really_overloaded_fn): Likewise.
kono
parents:
diff changeset
204 * error.c (dump_decl): Handle TEMPLATE_ID_EXPRs better.
kono
parents:
diff changeset
205 * pt.c (check_explicit_specialization): Tweak.
kono
parents:
diff changeset
206 (determine_explicit_specialization): Tweak.
kono
parents:
diff changeset
207
kono
parents:
diff changeset
208 * tree.c, cp-tree.h (get_target_expr): New fn.
kono
parents:
diff changeset
209
kono
parents:
diff changeset
210 Wed Dec 3 08:47:27 1997 Paul Eggert <eggert@twinsun.com>
kono
parents:
diff changeset
211
kono
parents:
diff changeset
212 * pt.c (check_explicit_specialization): Fix misspelling in
kono
parents:
diff changeset
213 diagnostic: `preceeded'.
kono
parents:
diff changeset
214 * typeck.c (get_delta_difference): Fix misspelling in diagnostic:
kono
parents:
diff changeset
215 `conversiona'.
kono
parents:
diff changeset
216
kono
parents:
diff changeset
217 1997-12-02 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
218
kono
parents:
diff changeset
219 * pt.c (determine_explicit_specialization): Avoid an internal
kono
parents:
diff changeset
220 error for bad specializations.
kono
parents:
diff changeset
221
kono
parents:
diff changeset
222 * method.c (build_overload_value): Handle SCOPE_REF.
kono
parents:
diff changeset
223
kono
parents:
diff changeset
224 Tue Dec 2 19:18:50 1997 Mike Stump <mrs@wrs.com>
kono
parents:
diff changeset
225
kono
parents:
diff changeset
226 * class.c (prepare_fresh_vtable): Enable even more complex MI
kono
parents:
diff changeset
227 vtable names.
kono
parents:
diff changeset
228
kono
parents:
diff changeset
229 Tue Dec 2 01:37:19 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
230
kono
parents:
diff changeset
231 * exception.cc (__check_eh_spec): Optimize a bit.
kono
parents:
diff changeset
232
kono
parents:
diff changeset
233 * exception.cc (__cp_pop_exception): Lose handler arg.
kono
parents:
diff changeset
234 * except.c (do_pop_exception): Likewise.
kono
parents:
diff changeset
235 (push_eh_cleanup): Let the cleanup mechanism supply the handler.
kono
parents:
diff changeset
236 (expand_end_catch_block): Likewise.
kono
parents:
diff changeset
237
kono
parents:
diff changeset
238 Fri Nov 28 01:58:14 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
239
kono
parents:
diff changeset
240 * pt.c (check_explicit_specialization): Complain about using a
kono
parents:
diff changeset
241 template-id for a non-specialization.
kono
parents:
diff changeset
242
kono
parents:
diff changeset
243 Fri Nov 28 12:35:19 1997 Scott Christley <scottc@net-community.com>
kono
parents:
diff changeset
244
kono
parents:
diff changeset
245 * repo.c: Prototype rindex only if needed.
kono
parents:
diff changeset
246 * xref.c: Likewise.
kono
parents:
diff changeset
247
kono
parents:
diff changeset
248 Fri Nov 28 01:56:35 1997 Bruno Haible <bruno@linuix.mathematik.uni-karlsruhe.de>
kono
parents:
diff changeset
249
kono
parents:
diff changeset
250 * error.c (dump_decl): Handle TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
251
kono
parents:
diff changeset
252 Thu Nov 27 00:59:46 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
253
kono
parents:
diff changeset
254 * typeck.c (build_const_cast): Handle references here instead of
kono
parents:
diff changeset
255 handing off to convert_to_reference.
kono
parents:
diff changeset
256
kono
parents:
diff changeset
257 * except.c: Lose Unexpected, SetTerminate, SetUnexpected,
kono
parents:
diff changeset
258 TerminateFunctionCall.
kono
parents:
diff changeset
259 (init_exception_processing): Likewise. Terminate et al are now
kono
parents:
diff changeset
260 the fns, not ADDR_EXPRs.
kono
parents:
diff changeset
261 (various): Lose redundant assemble_external calls.
kono
parents:
diff changeset
262 (do_unwind): s/BuiltinReturnAddress/builtin_return_address_fndecl/.
kono
parents:
diff changeset
263
kono
parents:
diff changeset
264 * cp-tree.h (struct lang_decl_flags): Add comdat.
kono
parents:
diff changeset
265 (DECL_COMDAT): New macro.
kono
parents:
diff changeset
266 * decl.c (duplicate_decls): Propagate it.
kono
parents:
diff changeset
267 (cp_finish_decl): Handle it.
kono
parents:
diff changeset
268 * decl2.c (import_export_decl): Just set DECL_COMDAT on VAR_DECLs.
kono
parents:
diff changeset
269
kono
parents:
diff changeset
270 * class.c: Remove static pending_hard_virtuals.
kono
parents:
diff changeset
271 (add_virtual_function): Take pointers to pending_virtuals
kono
parents:
diff changeset
272 and pending_hard_virtuals.
kono
parents:
diff changeset
273 (finish_struct_1): Pass them. Declare pending_hard_virtuals.
kono
parents:
diff changeset
274
kono
parents:
diff changeset
275 Wed Nov 26 20:28:49 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
276
kono
parents:
diff changeset
277 * decl2.c (import_export_vtable): If we support one_only but not
kono
parents:
diff changeset
278 weak symbols, mark instantiated template vtables one_only.
kono
parents:
diff changeset
279 (import_export_decl): Likewise for tinfo functions.
kono
parents:
diff changeset
280 (finish_vtable_vardecl): Also write out vtables from explicitly
kono
parents:
diff changeset
281 instantiated template classes.
kono
parents:
diff changeset
282 * pt.c (mark_class_instantiated): Revert last change.
kono
parents:
diff changeset
283
kono
parents:
diff changeset
284 * except.c (expand_throw): Call mark_used on the destructor.
kono
parents:
diff changeset
285
kono
parents:
diff changeset
286 Wed Nov 26 15:13:48 1997 Jeffrey A Law (law@cygnus.com)
kono
parents:
diff changeset
287
kono
parents:
diff changeset
288 * lex.c (lang_init): Enable flag_exceptions by default if no
kono
parents:
diff changeset
289 command line switch was specified.
kono
parents:
diff changeset
290
kono
parents:
diff changeset
291 1997-11-26 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
292
kono
parents:
diff changeset
293 * pt.c (unify): Handle `void' template parameters in
kono
parents:
diff changeset
294 specializations.
kono
parents:
diff changeset
295
kono
parents:
diff changeset
296 Wed Nov 26 01:11:24 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
297
kono
parents:
diff changeset
298 * rtti.c (build_dynamic_cast): Handle template case here.
kono
parents:
diff changeset
299 (build_dynamic_cast_1): Not here.
kono
parents:
diff changeset
300
kono
parents:
diff changeset
301 * typeck2.c (digest_init): Make copies where appropriate.
kono
parents:
diff changeset
302
kono
parents:
diff changeset
303 * decl2.c (delete_sanity): resolve_offset_ref.
kono
parents:
diff changeset
304
kono
parents:
diff changeset
305 * except.c: Call terminate without caching so many bits.
kono
parents:
diff changeset
306
kono
parents:
diff changeset
307 * except.c (expand_start_catch_block): Fix catching a reference
kono
parents:
diff changeset
308 to pointer.
kono
parents:
diff changeset
309
kono
parents:
diff changeset
310 Tue Nov 25 11:28:21 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
311
kono
parents:
diff changeset
312 * init.c (build_new): Copy size to the saveable obstack.
kono
parents:
diff changeset
313
kono
parents:
diff changeset
314 * init.c (build_new): Stick a CLEANUP_POINT_EXPR inside the
kono
parents:
diff changeset
315 TRY_CATCH_EXPR for now.
kono
parents:
diff changeset
316
kono
parents:
diff changeset
317 Mon Nov 24 12:15:55 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
318
kono
parents:
diff changeset
319 * typeck.c (mark_addressable): Don't assume a FUNCTION_DECL
kono
parents:
diff changeset
320 has DECL_LANG_SPECIFIC.
kono
parents:
diff changeset
321
kono
parents:
diff changeset
322 * exception.cc (struct cp_eh_info): Add handlers field.
kono
parents:
diff changeset
323 (__cp_push_exception): Initialize it.
kono
parents:
diff changeset
324 (__cp_pop_exception): Decrement it. Don't pop unless it's 0.
kono
parents:
diff changeset
325 (__throw_bad_exception): Remove.
kono
parents:
diff changeset
326 * except.c (call_eh_info): Add handlers field.
kono
parents:
diff changeset
327 (get_eh_handlers): New fn.
kono
parents:
diff changeset
328 (push_eh_cleanup): Increment handlers.
kono
parents:
diff changeset
329
kono
parents:
diff changeset
330 Fri Nov 21 12:22:07 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
331
kono
parents:
diff changeset
332 * except.c (expand_start_eh_spec): Use the try/catch code.
kono
parents:
diff changeset
333 (expand_end_eh_spec): Likewise. Call __check_eh_spec instead of
kono
parents:
diff changeset
334 doing everything inline.
kono
parents:
diff changeset
335 (init_exception_processing): throw_type_match now takes
kono
parents:
diff changeset
336 const void pointers.
kono
parents:
diff changeset
337 * exception.cc (__check_eh_spec): New fn.
kono
parents:
diff changeset
338 * inc/exception: Neither terminate nor unexpected return.
kono
parents:
diff changeset
339 * decl.c: Make const_ptr_type_node public.
kono
parents:
diff changeset
340 * tinfo2.cc (__throw_type_match_rtti): Take the typeinfos constly.
kono
parents:
diff changeset
341
kono
parents:
diff changeset
342 * except.c (expand_start_catch_block): We only need the rethrow
kono
parents:
diff changeset
343 region for non-sjlj exceptions.
kono
parents:
diff changeset
344 (expand_end_catch_block): Likewise. Use outer_context_label_stack.
kono
parents:
diff changeset
345
kono
parents:
diff changeset
346 Thu Nov 20 14:40:17 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
347
kono
parents:
diff changeset
348 * Make-lang.in (CXX_LIB2FUNCS): Add new op new and op delete objs.
kono
parents:
diff changeset
349 (various.o): Likewise.
kono
parents:
diff changeset
350 * inc/new: Add placement deletes. Add throw specs for default new.
kono
parents:
diff changeset
351 * new.cc (set_new_handler): Move here from libgcc2.
kono
parents:
diff changeset
352 * new1.cc (new (nothrow)): Catch a bad_alloc thrown from the handler.
kono
parents:
diff changeset
353 (new): Move from libgcc2. Throw bad_alloc.
kono
parents:
diff changeset
354 * new2.cc: Move the rest of the op news and op deletes from libgcc2.
kono
parents:
diff changeset
355 * decl.c (init_decl_processing): Update exception specs on new and
kono
parents:
diff changeset
356 delete.
kono
parents:
diff changeset
357
kono
parents:
diff changeset
358 * method.c (build_decl_overload_real): Don't mess with global
kono
parents:
diff changeset
359 placement delete.
kono
parents:
diff changeset
360
kono
parents:
diff changeset
361 * init.c (build_new): Check for null throw spec, not nothrow_t.
kono
parents:
diff changeset
362
kono
parents:
diff changeset
363 * decl.c (duplicate_decls): Don't complain about different exceptions
kono
parents:
diff changeset
364 from an internal declaration.
kono
parents:
diff changeset
365
kono
parents:
diff changeset
366 * call.c (build_op_delete_call): Fix check for member fns again.
kono
parents:
diff changeset
367
kono
parents:
diff changeset
368 * decl2.c (import_export_decl): Interface hackery affects
kono
parents:
diff changeset
369 virtual synthesized methods.
kono
parents:
diff changeset
370
kono
parents:
diff changeset
371 Wed Nov 19 18:24:14 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
372
kono
parents:
diff changeset
373 * decl.c (start_decl): Don't just complain about a mismatched
kono
parents:
diff changeset
374 scope, fix it.
kono
parents:
diff changeset
375
kono
parents:
diff changeset
376 * decl.c (make_implicit_typename): Handle case where t is not
kono
parents:
diff changeset
377 actually from context.
kono
parents:
diff changeset
378 * tree.c (get_type_decl): Lose identifier case.
kono
parents:
diff changeset
379 * spew.c (yylex): Lose useless call to identifier_typedecl_value.
kono
parents:
diff changeset
380 * parse.y (nonnested_type): Just use lookup_name.
kono
parents:
diff changeset
381 (complex_type_name): Just use IDENTIFIER_GLOBAL_VALUE.
kono
parents:
diff changeset
382
kono
parents:
diff changeset
383 Wed Nov 19 11:45:07 1997 Michael Tiemann <tiemann@axon.cygnus.com>
kono
parents:
diff changeset
384
kono
parents:
diff changeset
385 * error.c (dump_function_name): Test DECL_LANG_SPECIFIC in case
kono
parents:
diff changeset
386 T was built in C language context (for example, by
kono
parents:
diff changeset
387 output_func_start_profiler).
kono
parents:
diff changeset
388
kono
parents:
diff changeset
389 Wed Nov 19 10:39:27 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
390
kono
parents:
diff changeset
391 * decl.c (make_implicit_typename): New fn.
kono
parents:
diff changeset
392 (lookup_name_real): Use it. Use current_class_type as the context.
kono
parents:
diff changeset
393
kono
parents:
diff changeset
394 Mon Nov 17 23:42:03 1997 Bruno Haible <haible@ilog.fr>
kono
parents:
diff changeset
395
kono
parents:
diff changeset
396 * pt.c (do_poplevel): Don't prohibit jumps into this contour.
kono
parents:
diff changeset
397
kono
parents:
diff changeset
398 Mon Nov 17 02:01:28 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
399
kono
parents:
diff changeset
400 * friend.c (do_friend): Warn about non-template friends in templates.
kono
parents:
diff changeset
401
kono
parents:
diff changeset
402 * call.c (build_op_delete_call): Fix handling of inherited delete.
kono
parents:
diff changeset
403
kono
parents:
diff changeset
404 * search.c (dfs_record_inheritance): Ignore template type parms.
kono
parents:
diff changeset
405
kono
parents:
diff changeset
406 Sat Nov 15 00:30:51 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
407
kono
parents:
diff changeset
408 * call.c (build_new_op): Fix copy error.
kono
parents:
diff changeset
409 (build_op_new_call): New fn.
kono
parents:
diff changeset
410 (build_op_delete_call): New fn.
kono
parents:
diff changeset
411 * cp-tree.h: Declare them.
kono
parents:
diff changeset
412 * init.c (build_new): Use them. Support placement delete.
kono
parents:
diff changeset
413 (build_x_delete): Use build_op_delete_call.
kono
parents:
diff changeset
414 (build_delete): Likewise.
kono
parents:
diff changeset
415 * decl2.c (delete_sanity): Likewise.
kono
parents:
diff changeset
416 (coerce_delete_type): Don't complain about placement delete.
kono
parents:
diff changeset
417
kono
parents:
diff changeset
418 Thu Nov 13 01:52:36 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
419
kono
parents:
diff changeset
420 * call.c (build_new_function_call): Remove unused 'obj' parm.
kono
parents:
diff changeset
421 * cp-tree.h, typeck.c: Adjust.
kono
parents:
diff changeset
422
kono
parents:
diff changeset
423 * init.c (build_new): Make the cleanup last longer.
kono
parents:
diff changeset
424 (expand_vec_init): Call do_pending_stack_adjust.
kono
parents:
diff changeset
425
kono
parents:
diff changeset
426 Wed Nov 12 11:04:33 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
427
kono
parents:
diff changeset
428 * pt.c (do_type_instantiation): Fix typo.
kono
parents:
diff changeset
429 (mark_class_instantiated): If we support one_only but not weak
kono
parents:
diff changeset
430 symbols, don't mark this as known.
kono
parents:
diff changeset
431
kono
parents:
diff changeset
432 * init.c (build_new): Handle vec delete in EH cleanup.
kono
parents:
diff changeset
433
kono
parents:
diff changeset
434 Wed Nov 12 08:11:55 1997 Benjamin Kosnik <bkoz@rhino.cygnus.com>
kono
parents:
diff changeset
435
kono
parents:
diff changeset
436 * call.c (build_method_call): Call complete_type before checking
kono
parents:
diff changeset
437 for destructor.
kono
parents:
diff changeset
438
kono
parents:
diff changeset
439 Sun Nov 9 01:29:55 1997 Jim Wilson (wilson@cygnus.com)
kono
parents:
diff changeset
440
kono
parents:
diff changeset
441 * decl.c (add_block_current_level): Delete.
kono
parents:
diff changeset
442 * init.c (build_vec_delete_1): Delete build_block and
kono
parents:
diff changeset
443 add_block_current_level calls.
kono
parents:
diff changeset
444
kono
parents:
diff changeset
445 Wed Nov 12 00:48:16 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
446
kono
parents:
diff changeset
447 * init.c (build_new): Handle freeing allocated memory when the
kono
parents:
diff changeset
448 constructor throws.
kono
parents:
diff changeset
449
kono
parents:
diff changeset
450 * call.c (build_new_method_call): Fix flags arg.
kono
parents:
diff changeset
451
kono
parents:
diff changeset
452 * pt.c (do_type_instantiation): Don't try to instantiate
kono
parents:
diff changeset
453 member templates.
kono
parents:
diff changeset
454 (mark_decl_instantiated): If we support one_only but not
kono
parents:
diff changeset
455 weak symbols, mark this one_only.
kono
parents:
diff changeset
456 * decl2.c (import_export_vtable): Don't defer handling of vtables
kono
parents:
diff changeset
457 if MULTIPLE_SYMBOL_SPACES.
kono
parents:
diff changeset
458
kono
parents:
diff changeset
459 Tue Nov 11 12:02:12 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
460
kono
parents:
diff changeset
461 * except.c (expand_end_catch_block): Lose call to __sjpopnthrow.
kono
parents:
diff changeset
462
kono
parents:
diff changeset
463 Tue Nov 11 02:53:44 1997 Jason Merrill <jason@lasher.cygnus.com>
kono
parents:
diff changeset
464
kono
parents:
diff changeset
465 * except.c (do_pop_exception): Return a value.
kono
parents:
diff changeset
466
kono
parents:
diff changeset
467 Mon Nov 10 20:25:31 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
468
kono
parents:
diff changeset
469 * call.c (build_new_method_call): Handle getting a
kono
parents:
diff changeset
470 TEMPLATE_ID_EXPR around a TEMPLATE_DECL. Don't look for a field
kono
parents:
diff changeset
471 if we got template parms.
kono
parents:
diff changeset
472 * typeck.c (build_x_function_call): Remember the TEMPLATE_ID_EXPR,
kono
parents:
diff changeset
473 not just the args.
kono
parents:
diff changeset
474 * decl2.c (build_expr_from_tree): Tweak last change.
kono
parents:
diff changeset
475 * pt.c (tsubst_copy): Use get_first_fn instead of TREE_VALUE.
kono
parents:
diff changeset
476 (maybe_fold_nontype_arg): Split out from tsubst_copy.
kono
parents:
diff changeset
477 * tree.c (get_first_fn): Just return a TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
478
kono
parents:
diff changeset
479 Mon Nov 10 20:08:38 1997 Kriang Lerdsuwanakij <lerdsuwa@scf-fs.usc.edu>
kono
parents:
diff changeset
480
kono
parents:
diff changeset
481 * pt.c (tsubst_copy): Handle explicit template arguments in
kono
parents:
diff changeset
482 function calls.
kono
parents:
diff changeset
483 * typeck.c (build_x_function_call): Likewise.
kono
parents:
diff changeset
484 * decl2.c (build_expr_from_tree): Lookup function name if it
kono
parents:
diff changeset
485 hasn't been done.
kono
parents:
diff changeset
486
kono
parents:
diff changeset
487 * pt.c (tsubst): Instantiate template functions properly when
kono
parents:
diff changeset
488 template parameter does not appear in function arguments and return
kono
parents:
diff changeset
489 type.
kono
parents:
diff changeset
490 (comp_template_args): Handle member templates required by tsubst.
kono
parents:
diff changeset
491
kono
parents:
diff changeset
492 Mon Nov 10 20:08:38 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
493
kono
parents:
diff changeset
494 * decl.c (grokdeclarator): Tweak conditions for pedwarn in
kono
parents:
diff changeset
495 previous change.
kono
parents:
diff changeset
496
kono
parents:
diff changeset
497 Mon Nov 10 20:08:29 1997 Bruno Haible <bruno@linuix.mathematik.uni-karlsruhe.de>
kono
parents:
diff changeset
498
kono
parents:
diff changeset
499 * pt.c (coerce_template_parms): Tweak error message.
kono
parents:
diff changeset
500
kono
parents:
diff changeset
501 * decl.c (grokdeclarator): If -Wreturn-type, warn everytime a
kono
parents:
diff changeset
502 return type defaults to `int', even if there are storage-class
kono
parents:
diff changeset
503 specifiers.
kono
parents:
diff changeset
504
kono
parents:
diff changeset
505 Mon Nov 10 03:04:20 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
506
kono
parents:
diff changeset
507 Complete nested exception support.
kono
parents:
diff changeset
508 * except.c (do_pop_exception): Split out...
kono
parents:
diff changeset
509 (push_eh_cleanup): From here. Handle the EH region by hand.
kono
parents:
diff changeset
510 (expand_start_catch_block): Add a new level for the catch parm.
kono
parents:
diff changeset
511 Move the rethrow region outside the two cleanup regions.
kono
parents:
diff changeset
512 Protect the initializer for the catch parm with terminate.
kono
parents:
diff changeset
513 (expand_end_catch_block): Likewise. End the region for the eh_cleanup.
kono
parents:
diff changeset
514 * exception.cc (__cp_pop_exception): Now takes two parms. Handle
kono
parents:
diff changeset
515 popping off the middle of the stack.
kono
parents:
diff changeset
516 * tree.c (lvalue_p, real_lvalue_p): Handle TRY_CATCH_EXPR,
kono
parents:
diff changeset
517 WITH_CLEANUP_EXPR, and UNSAVE_EXPR.
kono
parents:
diff changeset
518 (build_cplus_new): Only wrap CALL_EXPRs.
kono
parents:
diff changeset
519 * init.c (expand_default_init): Handle a TRY_CATCH_EXPR around
kono
parents:
diff changeset
520 the constructor call.
kono
parents:
diff changeset
521
kono
parents:
diff changeset
522 Sun Nov 9 18:00:26 1997 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
kono
parents:
diff changeset
523
kono
parents:
diff changeset
524 * Make-lang.in (c++.distdir): Make inc subdirectory.
kono
parents:
diff changeset
525
kono
parents:
diff changeset
526 Fri Nov 7 11:57:28 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
527
kono
parents:
diff changeset
528 * decl2.c (finish_file): Put back some code.
kono
parents:
diff changeset
529
kono
parents:
diff changeset
530 Thu Nov 6 11:28:14 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
531
kono
parents:
diff changeset
532 * decl2.c (finish_file): Remove redundant code.
kono
parents:
diff changeset
533 * method.c (emit_thunk): Don't let the backend defer generic thunks.
kono
parents:
diff changeset
534
kono
parents:
diff changeset
535 Wed Nov 5 23:52:50 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
536
kono
parents:
diff changeset
537 * except.c (call_eh_info): Split out...
kono
parents:
diff changeset
538 (push_eh_info): From here.
kono
parents:
diff changeset
539 (expand_builtin_throw): Use it.
kono
parents:
diff changeset
540 (expand_start_catch_block): Move region start back.
kono
parents:
diff changeset
541
kono
parents:
diff changeset
542 Tue Nov 4 13:45:10 1997 Doug Evans <devans@canuck.cygnus.com>
kono
parents:
diff changeset
543
kono
parents:
diff changeset
544 * lex.c (MULTIBYTE_CHARS): #undef if cross compiling.
kono
parents:
diff changeset
545 (real_yylex): Record wide strings using target endianness, not host.
kono
parents:
diff changeset
546
kono
parents:
diff changeset
547 1997-11-03 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
548
kono
parents:
diff changeset
549 * repo.c (rindex): Add decl unconditionally.
kono
parents:
diff changeset
550 (get_base_filename, open_repo_file): Don't cast rindex.
kono
parents:
diff changeset
551 * xref.c (rindex): Add decl unconditionally.
kono
parents:
diff changeset
552 (index): Remove unused decl.
kono
parents:
diff changeset
553 (open_xref_file): Don't cast rindex.
kono
parents:
diff changeset
554
kono
parents:
diff changeset
555 Sun Nov 2 15:04:12 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
556
kono
parents:
diff changeset
557 * class.c (build_vbase_path): Propagate the result type properly.
kono
parents:
diff changeset
558
kono
parents:
diff changeset
559 1997-11-01 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
560
kono
parents:
diff changeset
561 * except.c (expand_builtin_throw) [!DWARF2_UNWIND_INFO]: Replace
kono
parents:
diff changeset
562 remaining use of saved_throw_type with a call to get_eh_type.
kono
parents:
diff changeset
563
kono
parents:
diff changeset
564 1997-10-31 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
565
kono
parents:
diff changeset
566 * lex.c (FILE_NAME_NONDIRECTORY): Delete macro.
kono
parents:
diff changeset
567 (file_name_nondirectory): New function, doing the same as the macro.
kono
parents:
diff changeset
568 (set_typedecl_interface_info): Use it instead of the macro.
kono
parents:
diff changeset
569 (check_newline): Likewise.
kono
parents:
diff changeset
570 (handle_cp_pragma): Likewise.
kono
parents:
diff changeset
571
kono
parents:
diff changeset
572 * repo.c (get_base_filename): Cast result of rindex to char*.
kono
parents:
diff changeset
573 (open_repo_file): Likewise.
kono
parents:
diff changeset
574 * xref.c (open_xref_file): Likewise.
kono
parents:
diff changeset
575 * error.c (dump_char): Make its arg int, not char.
kono
parents:
diff changeset
576
kono
parents:
diff changeset
577 * except.c (push_eh_info): Pass the number of fields - 1 down, not
kono
parents:
diff changeset
578 the exact number of fields.
kono
parents:
diff changeset
579
kono
parents:
diff changeset
580 Fri Oct 31 01:47:57 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
581
kono
parents:
diff changeset
582 Support for nested exceptions.
kono
parents:
diff changeset
583 * tinfo2.cc (__is_pointer): New fn.
kono
parents:
diff changeset
584 * exception.cc (struct cp_eh_info): Define.
kono
parents:
diff changeset
585 (__cp_exception_info, __uncatch_exception): New fns.
kono
parents:
diff changeset
586 (__cp_push_exception, __cp_pop_exception): New fns.
kono
parents:
diff changeset
587 * except.c: Lose saved_throw_{type,value,cleanup,in_catch}.
kono
parents:
diff changeset
588 Lose empty_fndecl.
kono
parents:
diff changeset
589 (init_exception_processing): Likewise. __eh_pc is now external.
kono
parents:
diff changeset
590 (push_eh_info): New fn.
kono
parents:
diff changeset
591 (get_eh_{info,value,type,caught}): New fns.
kono
parents:
diff changeset
592 (push_eh_cleanup): Just call __cp_pop_exception.
kono
parents:
diff changeset
593 (expand_start_catch_block): Use push_eh_info. Start the eh region
kono
parents:
diff changeset
594 sooner.
kono
parents:
diff changeset
595 (expand_end_eh_spec): Use push_eh_info.
kono
parents:
diff changeset
596 (expand_throw): Call __cp_push_exception to set up the exception info.
kono
parents:
diff changeset
597 Just pass the destructor or 0 as the cleanup. Call __uncatch_exception
kono
parents:
diff changeset
598 when we rethrow.
kono
parents:
diff changeset
599 (expand_builtin_throw): Don't refer to empty_fndecl.
kono
parents:
diff changeset
600
kono
parents:
diff changeset
601 Thu Oct 23 02:01:30 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
602
kono
parents:
diff changeset
603 * pt.c (instantiate_decl): SET_DECL_IMPLICIT_INSTANTIATION on new decl.
kono
parents:
diff changeset
604
kono
parents:
diff changeset
605 1997-10-22 Brendan Kehoe <brendan@cygnus.com>
kono
parents:
diff changeset
606
kono
parents:
diff changeset
607 * method.c (build_template_parm_names, build_decl_overload_real):
kono
parents:
diff changeset
608 Add static to definitions.
kono
parents:
diff changeset
609 * pt.c (add_to_template_args, note_template_header,
kono
parents:
diff changeset
610 processing_explicit_specialization, type_unification_real): Likewise.
kono
parents:
diff changeset
611 ({determine,check}_explicit_specialization): Use a single string for
kono
parents:
diff changeset
612 error messages.
kono
parents:
diff changeset
613
kono
parents:
diff changeset
614 Mon Oct 20 12:06:34 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
615
kono
parents:
diff changeset
616 * except.c (expand_exception_blocks): Call do_pending_stack_adjust.
kono
parents:
diff changeset
617 (expand_end_catch_block): Likewise.
kono
parents:
diff changeset
618 (expand_end_eh_spec): Likewise.
kono
parents:
diff changeset
619
kono
parents:
diff changeset
620 Mon Oct 20 11:44:20 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
621
kono
parents:
diff changeset
622 * decl.c (duplicate_decls): Handle template specializations
kono
parents:
diff changeset
623 correctly.
kono
parents:
diff changeset
624 * error.c (dump_function_name): Fix printing of specializations of
kono
parents:
diff changeset
625 member functions that are not member templates.
kono
parents:
diff changeset
626 * cp-tree.h (processing_specialization): Make global.
kono
parents:
diff changeset
627 * pt.c (processing_specialization): Likewise.
kono
parents:
diff changeset
628 * lex.c (cons_up_default_function): Save and restore
kono
parents:
diff changeset
629 processing_specialization to avoid confusion.
kono
parents:
diff changeset
630
kono
parents:
diff changeset
631 Mon Oct 20 10:52:22 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
632
kono
parents:
diff changeset
633 * decl.c (init_decl_processing): Give null_node unknown* type.
kono
parents:
diff changeset
634 * typeck.c (comp_target_types): Handle UNKNOWN_TYPE.
kono
parents:
diff changeset
635 (common_type): Likewise.
kono
parents:
diff changeset
636 * error.c (args_as_string): Recognize null_node.
kono
parents:
diff changeset
637
kono
parents:
diff changeset
638 Sun Oct 19 09:13:01 1997 Richard Kenner <kenner@vlsi1.ultra.nyu.edu>
kono
parents:
diff changeset
639
kono
parents:
diff changeset
640 * typeck.c (rationalize_conditional_expr): Handle {MIN,MAX}_EXPR.
kono
parents:
diff changeset
641 (unary_complex_lvalue): Call it for {MIN,MAX}_EXPR.
kono
parents:
diff changeset
642
kono
parents:
diff changeset
643 * decl.c (init_decl_processing): Call using_eh_for_cleanups.
kono
parents:
diff changeset
644
kono
parents:
diff changeset
645 * Make-lang.in (g++): Include prefix.o.
kono
parents:
diff changeset
646
kono
parents:
diff changeset
647 Thu Oct 16 15:31:09 1997 Judy Goldberg <judygold@sanwafp.com>
kono
parents:
diff changeset
648
kono
parents:
diff changeset
649 * pt.c (determine_explicit_specialization): Initialize "dummy"
kono
parents:
diff changeset
650 to keep Purify quiet.
kono
parents:
diff changeset
651
kono
parents:
diff changeset
652 Thu Oct 16 00:14:48 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
653
kono
parents:
diff changeset
654 * method.c (build_overload_value): Handle TEMPLATE_CONST_PARMs here.
kono
parents:
diff changeset
655 (build_overload_int): Not here.
kono
parents:
diff changeset
656
kono
parents:
diff changeset
657 Wed Oct 15 00:35:28 1997 Mike Stump <mrs@wrs.com>
kono
parents:
diff changeset
658
kono
parents:
diff changeset
659 * class.c (build_type_pathname): Remove.
kono
parents:
diff changeset
660 (prepare_fresh_vtable): Fix problem with complex MI vtable names.
kono
parents:
diff changeset
661
kono
parents:
diff changeset
662 1997-10-14 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
663
kono
parents:
diff changeset
664 * parse.y (unary_expr): Give a pedwarn if someone tries to use the
kono
parents:
diff changeset
665 &&label GNU extension.
kono
parents:
diff changeset
666
kono
parents:
diff changeset
667 Tue Oct 14 12:01:00 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
668
kono
parents:
diff changeset
669 * decl.c (pushtag): Unset DECL_ASSEMBLER_NAME before setting it,
kono
parents:
diff changeset
670 so as to avoid incorrect manglings.
kono
parents:
diff changeset
671 * method.c (build_decl_overload_real): Don't mangle return types
kono
parents:
diff changeset
672 for constructors.
kono
parents:
diff changeset
673
kono
parents:
diff changeset
674 Tue Oct 14 11:46:14 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
675
kono
parents:
diff changeset
676 * cp-tree.h (scratchalloc, build_scratch_list, make_scratch_vec,
kono
parents:
diff changeset
677 scratch_tree_cons): Define as macros for now.
kono
parents:
diff changeset
678 * call.c, class.c, cvt.c, decl.c, decl2.c, except.c, expr.c, init.c,
kono
parents:
diff changeset
679 lex.c, method.c, parse.y, pt.c, rtti.c, search.c, tree.c, typeck.c,
kono
parents:
diff changeset
680 typeck2.c: Use them and the expression_obstack variants.
kono
parents:
diff changeset
681
kono
parents:
diff changeset
682 Mon Oct 13 17:41:26 1997 Benjamin Kosnik <bkoz@rhino.cygnus.com>
kono
parents:
diff changeset
683
kono
parents:
diff changeset
684 * decl.c (store_return_init): Allow classes with explicit ctors to
kono
parents:
diff changeset
685 be used with the named return values extension.
kono
parents:
diff changeset
686
kono
parents:
diff changeset
687 Fri Oct 10 12:21:11 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
688
kono
parents:
diff changeset
689 * pt.c (instantiate_decl): Fix previous change.
kono
parents:
diff changeset
690
kono
parents:
diff changeset
691 Thu Oct 9 12:08:21 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
692
kono
parents:
diff changeset
693 * pt.c (tsubst): Fix thinko.
kono
parents:
diff changeset
694 (instantiate_decl): Really use the original template.
kono
parents:
diff changeset
695
kono
parents:
diff changeset
696 * call.c (build_new_method_call): Use simple constructor_name for
kono
parents:
diff changeset
697 error messages.
kono
parents:
diff changeset
698
kono
parents:
diff changeset
699 Wed Oct 8 22:44:42 1997 Jeffrey A Law <law@cygnus.com>
kono
parents:
diff changeset
700
kono
parents:
diff changeset
701 * method.c (build_underscore_int): Don't use ANSI specific
kono
parents:
diff changeset
702 features.
kono
parents:
diff changeset
703
kono
parents:
diff changeset
704 Wed Oct 8 00:18:22 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
705
kono
parents:
diff changeset
706 * decl2.c (finish_prevtable_vardecl): Check DECL_REALLY_EXTERN
kono
parents:
diff changeset
707 for our key method; it might have been inlined by -O3.
kono
parents:
diff changeset
708
kono
parents:
diff changeset
709 Tue Oct 7 23:00:12 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
710
kono
parents:
diff changeset
711 * decl.c (make_typename_type): Do not try to call lookup_field for
kono
parents:
diff changeset
712 non-aggregate types.
kono
parents:
diff changeset
713
kono
parents:
diff changeset
714 Tue Oct 7 22:52:10 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
715
kono
parents:
diff changeset
716 * typeck.c (build_reinterpret_cast): Tweak.
kono
parents:
diff changeset
717
kono
parents:
diff changeset
718 Tue Oct 7 22:45:31 1997 Alexandre Oliva <oliva@dcc.unicamp.br>
kono
parents:
diff changeset
719
kono
parents:
diff changeset
720 * typeck.c (build_reinterpret_cast): Converting a void pointer
kono
parents:
diff changeset
721 to function pointer with a reinterpret_cast produces a warning
kono
parents:
diff changeset
722 if -pedantic is issued.
kono
parents:
diff changeset
723
kono
parents:
diff changeset
724 Tue Oct 7 22:43:43 1997 Bruno Haible <bruno@linuix.mathematik.uni-karlsruhe.de>
kono
parents:
diff changeset
725
kono
parents:
diff changeset
726 * typeck.c (c_expand_return): Don't warn about returning a
kono
parents:
diff changeset
727 reference-type variable as a reference.
kono
parents:
diff changeset
728
kono
parents:
diff changeset
729 Tue Oct 7 21:11:22 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
730
kono
parents:
diff changeset
731 * method.c (build_static_name): Fix typo.
kono
parents:
diff changeset
732
kono
parents:
diff changeset
733 1997-10-07 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
734
kono
parents:
diff changeset
735 * decl.c (duplicate_decls): Make sure DECL_LANG_SPECIFIC is set on
kono
parents:
diff changeset
736 OLDDECL before we try to do DECL_USE_TEMPLATE.
kono
parents:
diff changeset
737
kono
parents:
diff changeset
738 Tue Oct 7 00:48:36 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
739
kono
parents:
diff changeset
740 * decl.c (duplicate_decls): Don't warn about template instances.
kono
parents:
diff changeset
741
kono
parents:
diff changeset
742 * typeck.c (mark_addressable): Lose ancient code that unsets
kono
parents:
diff changeset
743 DECL_EXTERNAL.
kono
parents:
diff changeset
744
kono
parents:
diff changeset
745 * pt.c (do_decl_instantiation): Lose support for instantiating
kono
parents:
diff changeset
746 non-templates.
kono
parents:
diff changeset
747
kono
parents:
diff changeset
748 * call.c (build_new_function_call): Fix handling of null explicit
kono
parents:
diff changeset
749 template args.
kono
parents:
diff changeset
750 (build_new_method_call): Likewise.
kono
parents:
diff changeset
751
kono
parents:
diff changeset
752 Mon Oct 6 23:44:34 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
753
kono
parents:
diff changeset
754 * method.c (build_underscore_int): Fix typo.
kono
parents:
diff changeset
755
kono
parents:
diff changeset
756 1997-10-06 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
757
kono
parents:
diff changeset
758 * tree.c (print_lang_statistics): #if 0 call to
kono
parents:
diff changeset
759 print_inline_obstack_statistics until its definition is checked in.
kono
parents:
diff changeset
760
kono
parents:
diff changeset
761 Mon Oct 6 09:27:29 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
762
kono
parents:
diff changeset
763 * decl2.c (finish_file): Move dump_tree_statistics to end.
kono
parents:
diff changeset
764
kono
parents:
diff changeset
765 * pt.c (instantiate_decl): Look for the original template.
kono
parents:
diff changeset
766 (tsubst): Set DECL_IMPLICIT_INSTANTIATION on partial instantiations
kono
parents:
diff changeset
767 of member templates.
kono
parents:
diff changeset
768
kono
parents:
diff changeset
769 Wed Oct 1 08:41:38 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
770
kono
parents:
diff changeset
771 * Makefile.in (g++FAQ.*): New rules.
kono
parents:
diff changeset
772 (CONFLICTS): Update.
kono
parents:
diff changeset
773 * g++FAQ.texi: Moved from libg++.
kono
parents:
diff changeset
774
kono
parents:
diff changeset
775 * parse.y (PFUNCNAME): Only specify the type once.
kono
parents:
diff changeset
776
kono
parents:
diff changeset
777 1997-10-01 Brendan Kehoe <brendan@lasher.cygnus.com>
kono
parents:
diff changeset
778
kono
parents:
diff changeset
779 * lex.c (real_yylex): Clean up the code to fully behave the way
kono
parents:
diff changeset
780 the c-lex.c parser does for complex and real numbers.
kono
parents:
diff changeset
781
kono
parents:
diff changeset
782 Tue Sep 30 08:51:36 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
783
kono
parents:
diff changeset
784 * method.c (build_decl_overload_real): Reformat.
kono
parents:
diff changeset
785
kono
parents:
diff changeset
786 Tue Sep 30 00:18:26 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
787
kono
parents:
diff changeset
788 * method.c (synthesize_method): If at_eof, determine our linkage.
kono
parents:
diff changeset
789
kono
parents:
diff changeset
790 1997-09-29 Paul Eggert <eggert@twinsun.com>
kono
parents:
diff changeset
791
kono
parents:
diff changeset
792 * lex.c (real_yylex): Treat `$' just like `_', except issue a
kono
parents:
diff changeset
793 diagnostic if !dollars_in_ident or if pedantic.
kono
parents:
diff changeset
794
kono
parents:
diff changeset
795 * lang-specs.h (@c++): -ansi no longer implies -$.
kono
parents:
diff changeset
796
kono
parents:
diff changeset
797 * decl2.c (lang_decode_option):
kono
parents:
diff changeset
798 -traditional and -ansi now do not mess with
kono
parents:
diff changeset
799 dollars_in_ident.
kono
parents:
diff changeset
800
kono
parents:
diff changeset
801 Mon Sep 29 19:57:51 1997 H.J. Lu <hjl@gnu.ai.mit.edu>
kono
parents:
diff changeset
802
kono
parents:
diff changeset
803 * Makefile.in (parse.o, decl.o): Also depend on
kono
parents:
diff changeset
804 $(srcdir)/../except.h $(srcdir)/../output.h.
kono
parents:
diff changeset
805 (decl2.o): Also depend on $(srcdir)/../expr.h ../insn-codes.h
kono
parents:
diff changeset
806 $(srcdir)/../except.h $(srcdir)/../output.h.
kono
parents:
diff changeset
807 (typeck.o, init.o): Also depend on $(srcdir)/../expr.h
kono
parents:
diff changeset
808 ../insn-codes.h.
kono
parents:
diff changeset
809
kono
parents:
diff changeset
810 * call.c, cp-tree.h, decl.c, tree.c: Finish prototyping.
kono
parents:
diff changeset
811
kono
parents:
diff changeset
812 * expr.c (cplus_expand_expr): Make it static.
kono
parents:
diff changeset
813
kono
parents:
diff changeset
814 * decl2.c, init.c, typeck.c: Include "expr.h".
kono
parents:
diff changeset
815 (expand_expr): Use proper values when calling the function.
kono
parents:
diff changeset
816
kono
parents:
diff changeset
817 Mon Sep 29 11:05:54 1997 Alexandre Oliva <oliva@dcc.unicamp.br>
kono
parents:
diff changeset
818
kono
parents:
diff changeset
819 * lang-options.h: New -Wold-style-cast flag.
kono
parents:
diff changeset
820 * cp-tree.h (warn_old_style_cast): New variable.
kono
parents:
diff changeset
821 * decl2.c (warn_old_style_cast): Likewise.
kono
parents:
diff changeset
822 (lang_decode_option): Support -Wold-style-cast.
kono
parents:
diff changeset
823 (reparse_absdcl_as_casts): Produce old-style-cast warning.
kono
parents:
diff changeset
824
kono
parents:
diff changeset
825 Mon Sep 29 09:20:53 1997 Benjamin Kosnik <bkoz@rhino.cygnus.com>
kono
parents:
diff changeset
826
kono
parents:
diff changeset
827 * decl.c (cp_finish_decl): Allow expand_aggr_init to set
kono
parents:
diff changeset
828 TREE_USED, reset value based on already_used.
kono
parents:
diff changeset
829
kono
parents:
diff changeset
830 * init.c (expand_member_init): Revert change.
kono
parents:
diff changeset
831
kono
parents:
diff changeset
832 Mon Sep 29 08:57:53 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
833
kono
parents:
diff changeset
834 * cp-tree.h, decl.c, decl2.c, pt.c:
kono
parents:
diff changeset
835 Lose DECL_C_STATIC and DECL_PUBLIC. Don't pretend statics are public.
kono
parents:
diff changeset
836
kono
parents:
diff changeset
837 * decl2.c (lang_decode_option): Add missing ;.
kono
parents:
diff changeset
838
kono
parents:
diff changeset
839 Sat Sep 27 16:22:48 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
840
kono
parents:
diff changeset
841 * friend.c (do_friend): Disable injection for all template-derived
kono
parents:
diff changeset
842 decls.
kono
parents:
diff changeset
843 * decl2.c (lang_decode_option): Handle -fguiding-decls.
kono
parents:
diff changeset
844 * parse.y (notype_template_declarator): New nonterminal.
kono
parents:
diff changeset
845 (direct_notype_declarator): Use it.
kono
parents:
diff changeset
846 (complex_direct_notype_declarator): Likewise.
kono
parents:
diff changeset
847 (object_template_id): Accept any kind of identifier after TEMPLATE.
kono
parents:
diff changeset
848 (notype_qualified_id): Don't add template declarators here.
kono
parents:
diff changeset
849
kono
parents:
diff changeset
850 Sat Sep 27 16:21:58 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
851
kono
parents:
diff changeset
852 * call.c (add_template_candidate): Add explicit_targs parameter.
kono
parents:
diff changeset
853 (build_scoped_method_call): Use it.
kono
parents:
diff changeset
854 (build_overload_call_real): Likewise.
kono
parents:
diff changeset
855 (build_user_type_conversion_1): Likewise.
kono
parents:
diff changeset
856 (build_new_function_call): Likewise.
kono
parents:
diff changeset
857 (build_object_call): Likewise.
kono
parents:
diff changeset
858 (build_new_op): Likewise.
kono
parents:
diff changeset
859 (build_new_method_call): Likewise.
kono
parents:
diff changeset
860 (build_new_function_call): Handle TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
861 (build_new_method_call): Likewise.
kono
parents:
diff changeset
862
kono
parents:
diff changeset
863 * class.c (finish_struct_methods): Add specialization pass to
kono
parents:
diff changeset
864 determine which methods were specializing which other methods.
kono
parents:
diff changeset
865 (instantiate_type): Handle TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
866
kono
parents:
diff changeset
867 * cp-tree.def (TEMPLATE_ID_EXPR): New tree code.
kono
parents:
diff changeset
868
kono
parents:
diff changeset
869 * cp-tree.h (name_mangling_version): New variable.
kono
parents:
diff changeset
870 (flag_guiding_decls): Likewise.
kono
parents:
diff changeset
871 (build_template_decl_overload): New function.
kono
parents:
diff changeset
872 (begin_specialization): Likewise.
kono
parents:
diff changeset
873 (reset_specialization): Likewise.
kono
parents:
diff changeset
874 (end_specialization): Likewise.
kono
parents:
diff changeset
875 (determine_explicit_specialization): Likewise.
kono
parents:
diff changeset
876 (check_explicit_specialization): Likewise.
kono
parents:
diff changeset
877 (lookup_template_function): Likewise.
kono
parents:
diff changeset
878 (fn_type_unification): Add explicit_targs parameter.
kono
parents:
diff changeset
879 (type_unification): Likewise.
kono
parents:
diff changeset
880
kono
parents:
diff changeset
881 * decl.c (duplicate_decls): Add smarts for explicit
kono
parents:
diff changeset
882 specializations.
kono
parents:
diff changeset
883 (grokdeclarator): Handle TEMPLATE_ID_EXPR, and function
kono
parents:
diff changeset
884 specializations.
kono
parents:
diff changeset
885 (grokfndecl): Call check_explicit_specialization.
kono
parents:
diff changeset
886
kono
parents:
diff changeset
887 * decl2.c (lang_decode_option): Handle -fname-mangling-version.
kono
parents:
diff changeset
888 (build_expr_from_tree): Handle TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
889 (check_classfn): Handle specializations.
kono
parents:
diff changeset
890
kono
parents:
diff changeset
891 * error.c (dump_function_name): Print specialization arguments.
kono
parents:
diff changeset
892
kono
parents:
diff changeset
893 * friend.c (do_friend): Don't call pushdecl for template
kono
parents:
diff changeset
894 instantiations.
kono
parents:
diff changeset
895
kono
parents:
diff changeset
896 * init.c (build_member_call): Handle TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
897
kono
parents:
diff changeset
898 * lang-options.h: Add -fname-mangling-version, -fguiding-decls,
kono
parents:
diff changeset
899 and -fno-guiding-decls.
kono
parents:
diff changeset
900
kono
parents:
diff changeset
901 * lex.c (identifier_type): Return PFUNCNAME for template function
kono
parents:
diff changeset
902 names.
kono
parents:
diff changeset
903
kono
parents:
diff changeset
904 * method.c (build_decl_overload_real): New function.
kono
parents:
diff changeset
905 (build_template_parm_names): New function.
kono
parents:
diff changeset
906 (build_overload_identifier): Use it.
kono
parents:
diff changeset
907 (build_underscore_int): New function.
kono
parents:
diff changeset
908 (build_overload_int): Use it. Add levels for template
kono
parents:
diff changeset
909 parameters.
kono
parents:
diff changeset
910 (build_overload_name): Likewise. Also, handle TYPENAME_TYPEs.
kono
parents:
diff changeset
911 (build_overload_nested_names): Handle template type parameters.
kono
parents:
diff changeset
912 (build_template_decl_overload): New function.
kono
parents:
diff changeset
913
kono
parents:
diff changeset
914 * parse.y (YYSTYPE): New ntype member.
kono
parents:
diff changeset
915 (nested_name_specifier): Use it.
kono
parents:
diff changeset
916 (nested_name_specifier_1): Likewise.
kono
parents:
diff changeset
917 (PFUNCNAME): New token.
kono
parents:
diff changeset
918 (template_id, object_template_id): New non-terminals.
kono
parents:
diff changeset
919 (template_parm_list): Note specializations.
kono
parents:
diff changeset
920 (template_def): Likewise.
kono
parents:
diff changeset
921 (structsp): Likewise.
kono
parents:
diff changeset
922 (fn.def2): Handle member template specializations.
kono
parents:
diff changeset
923 (component_decl_1): Likewise.
kono
parents:
diff changeset
924 (direct_notype_declarator): Handle template-ids.
kono
parents:
diff changeset
925 (component_decl_1): Likewise.
kono
parents:
diff changeset
926 (direct_notype_declarator): Handle template-ids.
kono
parents:
diff changeset
927 (primary): Handle TEMPLATE_ID_EXPR, and template-ids.
kono
parents:
diff changeset
928
kono
parents:
diff changeset
929 * pt.c (processing_specializations): New variable.
kono
parents:
diff changeset
930 (template_header_count): Likewise.
kono
parents:
diff changeset
931 (type_unification_real): New function.
kono
parents:
diff changeset
932 (processing_explicit_specialization): Likewise.
kono
parents:
diff changeset
933 (note_template_header): Likewise.
kono
parents:
diff changeset
934 (is_member_template): Handle specializations.
kono
parents:
diff changeset
935 (end_template_decl): Call reset_specialization.
kono
parents:
diff changeset
936 (push_template_decl): Handle member template specializations.
kono
parents:
diff changeset
937 (tsubst): Likewise.
kono
parents:
diff changeset
938 (tsubst_copy): Handle TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
939 (instantiate_template): Handle specializations.
kono
parents:
diff changeset
940 (instantiate_decl): Likewise.
kono
parents:
diff changeset
941 (fn_type_unification): Handle explicit_targs.
kono
parents:
diff changeset
942 (type_unification): Likewise. Allow incomplete unification
kono
parents:
diff changeset
943 without an error message, if allow_incomplete.
kono
parents:
diff changeset
944 (get_bindings): Use new calling sequence for fn_type_unification.
kono
parents:
diff changeset
945
kono
parents:
diff changeset
946 * spew.c (yylex): Handle PFUNCNAME.
kono
parents:
diff changeset
947
kono
parents:
diff changeset
948 * tree.c (is_overloaded_fn): Handle TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
949 (really_overloaded_fn): Likewise.
kono
parents:
diff changeset
950 (get_first_fn): Handle function templates.
kono
parents:
diff changeset
951
kono
parents:
diff changeset
952 * typeck.c (build_x_function_call): Use really_overloaded_fn.
kono
parents:
diff changeset
953 Handle TEMPLATE_ID_EXPR.
kono
parents:
diff changeset
954 (build_x_unary_op): Likewise.
kono
parents:
diff changeset
955 (build_unary_op): Likewise.
kono
parents:
diff changeset
956 (mark_addressable): Templates whose address is taken are marked
kono
parents:
diff changeset
957 as used.
kono
parents:
diff changeset
958
kono
parents:
diff changeset
959 1997-09-25 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
kono
parents:
diff changeset
960
kono
parents:
diff changeset
961 * decl.c (init_decl_processing): Declare __builtin_constant_p as
kono
parents:
diff changeset
962 accepting any kind of type, not only int.
kono
parents:
diff changeset
963
kono
parents:
diff changeset
964 Fri Sep 26 00:22:56 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
965
kono
parents:
diff changeset
966 * search.c (get_matching_virtual): Notice virtual bases when sorrying
kono
parents:
diff changeset
967 about covariant returns.
kono
parents:
diff changeset
968
kono
parents:
diff changeset
969 * parse.y (member_init): Also imply typename here. Remove ancient
kono
parents:
diff changeset
970 extension for initializing base members.
kono
parents:
diff changeset
971
kono
parents:
diff changeset
972 Thu Sep 25 11:11:13 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
973
kono
parents:
diff changeset
974 Handle multi-level typenames and implicit typename in base list.
kono
parents:
diff changeset
975 * parse.y (typename_sub{,[0-2]}): New rules.
kono
parents:
diff changeset
976 (structsp, rule TYPENAME_KEYWORD): Use typename_sub.
kono
parents:
diff changeset
977 (nonnested_type): New rule.
kono
parents:
diff changeset
978 (complete_type_name): Use it.
kono
parents:
diff changeset
979 (base_class.1): Use typename_sub and nonnested_type.
kono
parents:
diff changeset
980 (nested_name_specifier): Don't elide std:: here.
kono
parents:
diff changeset
981 * decl.c (make_typename_type): Handle getting a type for NAME.
kono
parents:
diff changeset
982 (lookup_name_real): Turn std:: into :: here.
kono
parents:
diff changeset
983
kono
parents:
diff changeset
984 Rvalue conversions were removed in London.
kono
parents:
diff changeset
985 * call.c (is_subseq): Don't consider lvalue transformations.
kono
parents:
diff changeset
986 (build_conv): LVALUE_CONV and RVALUE_CONV get IDENTITY_RANK.
kono
parents:
diff changeset
987 (joust): Re-enable ?: kludge.
kono
parents:
diff changeset
988
kono
parents:
diff changeset
989 1997-09-22 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
990
kono
parents:
diff changeset
991 * decl.c (start_function): Up warning of no return type to be a
kono
parents:
diff changeset
992 pedwarn.
kono
parents:
diff changeset
993
kono
parents:
diff changeset
994 Mon Sep 22 14:15:34 1997 Benjamin Kosnik <bkoz@rhino.cygnus.com>
kono
parents:
diff changeset
995
kono
parents:
diff changeset
996 * init.c (expand_member_init): Don't set TREE_USED.
kono
parents:
diff changeset
997 * decl.c (cp_finish_decl): Mark decls used if type has TREE_USED
kono
parents:
diff changeset
998 set,don't clear TREE_USED wholesale.
kono
parents:
diff changeset
999
kono
parents:
diff changeset
1000 Sat Sep 20 15:31:00 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1001
kono
parents:
diff changeset
1002 * call.c (build_over_call): Do require_complete_type before
kono
parents:
diff changeset
1003 build_cplus_new.
kono
parents:
diff changeset
1004
kono
parents:
diff changeset
1005 Thu Sep 18 16:47:52 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1006
kono
parents:
diff changeset
1007 * search.c (lookup_field): Call complete_type in all cases.
kono
parents:
diff changeset
1008
kono
parents:
diff changeset
1009 * decl.c (finish_function): Just warn about flowing off the end.
kono
parents:
diff changeset
1010
kono
parents:
diff changeset
1011 Wed Sep 17 10:31:25 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1012
kono
parents:
diff changeset
1013 * decl.c (grokparms): Don't bash a permanent list node if we're
kono
parents:
diff changeset
1014 in a function.
kono
parents:
diff changeset
1015
kono
parents:
diff changeset
1016 1997-09-17 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1017
kono
parents:
diff changeset
1018 * Makefile.in (CONFLICTS): Fix s/r conflict count to 18.
kono
parents:
diff changeset
1019
kono
parents:
diff changeset
1020 Tue Sep 16 14:06:56 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1021
kono
parents:
diff changeset
1022 * call.c (build_new_op): Give better error for syntactically
kono
parents:
diff changeset
1023 correct, but semantically invalid, use of undeclared template.
kono
parents:
diff changeset
1024
kono
parents:
diff changeset
1025 * call.c (compare_qual): Handle pmfs.
kono
parents:
diff changeset
1026
kono
parents:
diff changeset
1027 * decl.c (store_parm_decls): last_parm_cleanup_insn is the insn
kono
parents:
diff changeset
1028 after the exception spec.
kono
parents:
diff changeset
1029
kono
parents:
diff changeset
1030 Mon Sep 15 11:52:13 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1031
kono
parents:
diff changeset
1032 * call.c (null_ptr_cst_p): Integer type, not integral type.
kono
parents:
diff changeset
1033
kono
parents:
diff changeset
1034 * call.c (joust): Disable warnings until they can be moved to the
kono
parents:
diff changeset
1035 right place.
kono
parents:
diff changeset
1036
kono
parents:
diff changeset
1037 Fri Sep 12 16:11:13 1997 Per Bothner <bothner@cygnus.com>
kono
parents:
diff changeset
1038
kono
parents:
diff changeset
1039 * Makefile.in, config-lang.in: Convert to autoconf.
kono
parents:
diff changeset
1040
kono
parents:
diff changeset
1041 Thu Sep 11 17:14:55 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1042
kono
parents:
diff changeset
1043 * decl.c (lookup_name_real): Add implicit 'typename' to types from
kono
parents:
diff changeset
1044 base classes.
kono
parents:
diff changeset
1045
kono
parents:
diff changeset
1046 * pt.c (most_specialized_class): Fix typo.
kono
parents:
diff changeset
1047 (tsubst): Move constant folding to TREE_VEC case.
kono
parents:
diff changeset
1048
kono
parents:
diff changeset
1049 Thu Sep 11 10:08:45 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
1050
kono
parents:
diff changeset
1051 * pt.c (do_poplevel): Don't warn about unused local variables
kono
parents:
diff changeset
1052 while processing_template_decl since we don't always know whether
kono
parents:
diff changeset
1053 or not they will need constructing/destructing.
kono
parents:
diff changeset
1054
kono
parents:
diff changeset
1055 * pt.c (uses_template_parms): Check the values of an enumeration
kono
parents:
diff changeset
1056 type to make sure they don't depend on template parms.
kono
parents:
diff changeset
1057
kono
parents:
diff changeset
1058 * decl.c (make_typename_type): Don't lookup the field if the
kono
parents:
diff changeset
1059 context uses template parms, even if we're not
kono
parents:
diff changeset
1060 processing_template_decl at the moment.
kono
parents:
diff changeset
1061
kono
parents:
diff changeset
1062 * pt.c (coerce_template_parms): Avoid looking at the
kono
parents:
diff changeset
1063 TYPE_LANG_DECL portion of a typename type, since there won't be
kono
parents:
diff changeset
1064 one.
kono
parents:
diff changeset
1065 (tsubst): Do constant folding as necessary to make sure that
kono
parents:
diff changeset
1066 arguments passed to lookup_template_class really are constants.
kono
parents:
diff changeset
1067
kono
parents:
diff changeset
1068 Wed Sep 10 16:39:26 1997 Jim Wilson <wilson@cygnus.com>
kono
parents:
diff changeset
1069
kono
parents:
diff changeset
1070 * Make-lang.in (LN, LN_S): New macros, use where appropriate.
kono
parents:
diff changeset
1071
kono
parents:
diff changeset
1072 Wed Sep 10 11:21:55 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1073
kono
parents:
diff changeset
1074 * except.c (expand_builtin_throw): #ifndef DWARF2_UNWIND_INFO.
kono
parents:
diff changeset
1075 * decl2.c (finish_file): Only register exception tables if we
kono
parents:
diff changeset
1076 need to.
kono
parents:
diff changeset
1077
kono
parents:
diff changeset
1078 * decl.c (init_decl_processing): Add __builtin_[fs]p.
kono
parents:
diff changeset
1079
kono
parents:
diff changeset
1080 Tue Sep 9 19:49:38 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1081
kono
parents:
diff changeset
1082 * pt.c (unify): Just return 0 for a TYPENAME_TYPE.
kono
parents:
diff changeset
1083
kono
parents:
diff changeset
1084 Tue Sep 9 17:57:25 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
1085
kono
parents:
diff changeset
1086 * error.c (dump_decl): Avoid crashing when presented with a
kono
parents:
diff changeset
1087 uninitialized constant, as can occur with a template parameter.
kono
parents:
diff changeset
1088 (dump_expr): Make sure that there are enough levels of
kono
parents:
diff changeset
1089 current_template_parms before we start diving through them.
kono
parents:
diff changeset
1090
kono
parents:
diff changeset
1091 1997-09-09 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1092
kono
parents:
diff changeset
1093 * typeck.c (build_indirect_ref): Heed FLAG_VOLATILE similar to
kono
parents:
diff changeset
1094 c-typeck.c.
kono
parents:
diff changeset
1095
kono
parents:
diff changeset
1096 Tue Sep 9 09:36:39 1997 Benjamin Kosnik <bkoz@rhino.cygnus.com>
kono
parents:
diff changeset
1097
kono
parents:
diff changeset
1098 * except.c (expand_throw): Call build_delete for all
kono
parents:
diff changeset
1099 exception types, not just objects with destructors.
kono
parents:
diff changeset
1100
kono
parents:
diff changeset
1101 Mon Sep 8 02:33:20 1997 Jody Goldberg <jodyg@idt.net>
kono
parents:
diff changeset
1102
kono
parents:
diff changeset
1103 * decl.c (current_local_enum): Remove static.
kono
parents:
diff changeset
1104 * pt.c (tsubst_enum): Save and restore value of current_local_enum
kono
parents:
diff changeset
1105 in case template is expanded in enum decl.
kono
parents:
diff changeset
1106 (instantiate_class_template): Use new tsubst_enum signature.
kono
parents:
diff changeset
1107 (tsubst_expr): Likewise.
kono
parents:
diff changeset
1108
kono
parents:
diff changeset
1109 Mon Sep 8 01:21:43 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
1110
kono
parents:
diff changeset
1111 * pt.c (begin_member_template_processing): Take a function as
kono
parents:
diff changeset
1112 argument, not a set of template arguments. Use the template
kono
parents:
diff changeset
1113 parameters, rather than the arguments. Handle non-type parameters
kono
parents:
diff changeset
1114 correctly. Push a binding level for the parameters so that multiple
kono
parents:
diff changeset
1115 member templates using the same parameter names can be declared.
kono
parents:
diff changeset
1116 (end_member_template_processing): Pop the binding level.
kono
parents:
diff changeset
1117 (push_template_decl): Mark member templates as static when
kono
parents:
diff changeset
1118 appropriate.
kono
parents:
diff changeset
1119
kono
parents:
diff changeset
1120 * lex.c (do_pending_inlines): Pass the function, not its template
kono
parents:
diff changeset
1121 arguments, to begin_member_template_processing.
kono
parents:
diff changeset
1122 (process_next_inline): Likewise.
kono
parents:
diff changeset
1123 (do_pending_defargs): Likewise.
kono
parents:
diff changeset
1124
kono
parents:
diff changeset
1125 * error.c (dump_expr): Obtain the correct declaration for a
kono
parents:
diff changeset
1126 TEMPLATE_CONST_PARM.
kono
parents:
diff changeset
1127
kono
parents:
diff changeset
1128 * call.c (add_template_conv_candidate): New function.
kono
parents:
diff changeset
1129 (build_object_call): Handle member templates, as done in the other
kono
parents:
diff changeset
1130 build_ functions.
kono
parents:
diff changeset
1131
kono
parents:
diff changeset
1132 Sat Sep 6 10:20:27 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
1133
kono
parents:
diff changeset
1134 * decl.c (replace_defag): Undo previous change.
kono
parents:
diff changeset
1135 * lex.c (do_pending_defargs): Deal with member templates.
kono
parents:
diff changeset
1136
kono
parents:
diff changeset
1137 * pt.c (is_member_template): Avoid crashing when passed a
kono
parents:
diff changeset
1138 non-function argument.
kono
parents:
diff changeset
1139
kono
parents:
diff changeset
1140 Fri Sep 5 17:27:38 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1141
kono
parents:
diff changeset
1142 * class.c (grow_method): Remove check for redeclaration.
kono
parents:
diff changeset
1143
kono
parents:
diff changeset
1144 Fri Sep 5 01:37:17 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
1145
kono
parents:
diff changeset
1146 * cp-tree.h (INNERMOST_TEMPLATE_PARMS): New macro.
kono
parents:
diff changeset
1147 (DECL_INNERMOST_TEMPLATE_PARMS): Likewise.
kono
parents:
diff changeset
1148 (PRIMARY_TEMPLATE_P): Use it.
kono
parents:
diff changeset
1149 * call.c (build_overload_call_real): Use it.
kono
parents:
diff changeset
1150 * class.c (instantiate_type): Likewise.
kono
parents:
diff changeset
1151 * decl.c (decls_match): Likewise.
kono
parents:
diff changeset
1152 * method.c (build_overload_identifier): Likewise.
kono
parents:
diff changeset
1153 * pt.c (push_template_decl): Likewise.
kono
parents:
diff changeset
1154 (classtype_mangled_name): Likewise.
kono
parents:
diff changeset
1155 (lookup_template_class): Likewise.
kono
parents:
diff changeset
1156
kono
parents:
diff changeset
1157 * cp-tree.h (DECL_NTPARMS): Change name from DECL_NT_PARMS to
kono
parents:
diff changeset
1158 DECL_NTPARMS to conform to usage elsewhere.
kono
parents:
diff changeset
1159 * call.c (add_template_candidate): Likewise.
kono
parents:
diff changeset
1160 * class.c (instantiate_type): Likewise.
kono
parents:
diff changeset
1161 * pt.c (instantiate_template): Likewise.
kono
parents:
diff changeset
1162 (get_bindings): Likewise.
kono
parents:
diff changeset
1163
kono
parents:
diff changeset
1164 * class.c (grow_method): Use DECL_FUNCTION_TEMPLATE_P instead of
kono
parents:
diff changeset
1165 is_member_template.
kono
parents:
diff changeset
1166
kono
parents:
diff changeset
1167 * pt.c (unify): Undo changes to allow multiple levels of template
kono
parents:
diff changeset
1168 parameters.
kono
parents:
diff changeset
1169 (type_unification): Likewise.
kono
parents:
diff changeset
1170 (fn_type_unification): Likewise.
kono
parents:
diff changeset
1171 (get_class_bindings): Likewise.
kono
parents:
diff changeset
1172 * cp-tree.h (Likewise).
kono
parents:
diff changeset
1173
kono
parents:
diff changeset
1174 * decl.c (replace_defarg): Check that the type of the default
kono
parents:
diff changeset
1175 parameter does not invlove a template type before complaining
kono
parents:
diff changeset
1176 about the initialization.
kono
parents:
diff changeset
1177
kono
parents:
diff changeset
1178 * error.c (dump_expr): Deal with template constant parameters in
kono
parents:
diff changeset
1179 member templates correctly.
kono
parents:
diff changeset
1180
kono
parents:
diff changeset
1181 * pt.c (is_member_template): Deal with class specializations
kono
parents:
diff changeset
1182 correctly.
kono
parents:
diff changeset
1183 (tsubst): Handle "partial instantiation" of member templates
kono
parents:
diff changeset
1184 correctly.
kono
parents:
diff changeset
1185
kono
parents:
diff changeset
1186 Wed Sep 3 12:30:24 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
1187
kono
parents:
diff changeset
1188 * pt.c (type_unification): Change calling sequence to allow for
kono
parents:
diff changeset
1189 multiple levels of template parameters.
kono
parents:
diff changeset
1190 (tsubst_expr): Likewise.
kono
parents:
diff changeset
1191 (tsubst): Likewise.
kono
parents:
diff changeset
1192 (tsubst_copy): Likewise.
kono
parents:
diff changeset
1193 (instantiate_template): Likewise.
kono
parents:
diff changeset
1194 (unify): Likewise.
kono
parents:
diff changeset
1195 * call.c (build_overload_call_real): Use it.
kono
parents:
diff changeset
1196 (add_builtin_candidate): Use it.
kono
parents:
diff changeset
1197 (build_new_method_call): Use it.
kono
parents:
diff changeset
1198 * class.c (instantiate_type): Use it.
kono
parents:
diff changeset
1199 * decl.c (grokdeclarator): Use it.
kono
parents:
diff changeset
1200 * decl2.c (finish_file): Use it.
kono
parents:
diff changeset
1201 * method.c (build_overload_identifier): Use it.
kono
parents:
diff changeset
1202
kono
parents:
diff changeset
1203 * call.c (add_template_candidate): Add additional parameter for
kono
parents:
diff changeset
1204 the function return type. Call fn_type_unification istead of
kono
parents:
diff changeset
1205 type_unification.
kono
parents:
diff changeset
1206 (build_user_type_conversion_1): Handle member templates.
kono
parents:
diff changeset
1207 (build_new_function_call): Likewise.
kono
parents:
diff changeset
1208 (build_new_op): Likewise.
kono
parents:
diff changeset
1209 (build_new_method_call): Likewise.
kono
parents:
diff changeset
1210
kono
parents:
diff changeset
1211 * class.c (grow_method): Don't give an error message indicating
kono
parents:
diff changeset
1212 that two member templates with the same name are ambiguous.
kono
parents:
diff changeset
1213 (finish_struct): Treat member template functions just like member
kono
parents:
diff changeset
1214 functions.
kono
parents:
diff changeset
1215
kono
parents:
diff changeset
1216 * cp-tree.h (check_member_template): Add declaration.
kono
parents:
diff changeset
1217 (begin_member_template_processing): Likewise.
kono
parents:
diff changeset
1218 (end_member_template_processing): Likewise.
kono
parents:
diff changeset
1219 (fn_type_unification): Likewise.
kono
parents:
diff changeset
1220 (is_member_template): Likewise.
kono
parents:
diff changeset
1221 (tsubst): Change prototype.
kono
parents:
diff changeset
1222 (tsubst_expr): Likewise.
kono
parents:
diff changeset
1223 (tsubst_copy): Likewise.
kono
parents:
diff changeset
1224 (instantiate_template): Likewise.
kono
parents:
diff changeset
1225 (get_bindings): Likewise.
kono
parents:
diff changeset
1226
kono
parents:
diff changeset
1227 * decl.c (decls_match): Handle multiple levels of template
kono
parents:
diff changeset
1228 parameters.
kono
parents:
diff changeset
1229 (pushdecl): Handle template type params just like other type
kono
parents:
diff changeset
1230 declarations.
kono
parents:
diff changeset
1231 (push_class_level_binding): Return immediately if the
kono
parents:
diff changeset
1232 class_binding_level is NULL.
kono
parents:
diff changeset
1233 (grokfndecl): If check_classfn() returns a member_template, use
kono
parents:
diff changeset
1234 the result of the template, not the template itself.
kono
parents:
diff changeset
1235
kono
parents:
diff changeset
1236 * decl2.c (check_member_template): New function. Check to see
kono
parents:
diff changeset
1237 that the entity declared to be a member template can be one.
kono
parents:
diff changeset
1238 (check_classfn): Allow redeclaration of member template functions
kono
parents:
diff changeset
1239 with different types; the new functions can be specializations or
kono
parents:
diff changeset
1240 explicit instantiations.
kono
parents:
diff changeset
1241
kono
parents:
diff changeset
1242 * error.c (dump_decl): Handle multiple levels of template
kono
parents:
diff changeset
1243 parameters.
kono
parents:
diff changeset
1244 (dump_function_decl): Update to handle function templates.
kono
parents:
diff changeset
1245
kono
parents:
diff changeset
1246 * lex.c (do_pending_inlines): Set up template parameter context
kono
parents:
diff changeset
1247 for member templates.
kono
parents:
diff changeset
1248 (process_next_inline): Likewise.
kono
parents:
diff changeset
1249
kono
parents:
diff changeset
1250 * method.c (build_overload_identifier): Adjust for multiple levels
kono
parents:
diff changeset
1251 of template parameters.
kono
parents:
diff changeset
1252
kono
parents:
diff changeset
1253 * parse.y (fn.def2): Add member templates.
kono
parents:
diff changeset
1254 (component_decl_1): Likewise.
kono
parents:
diff changeset
1255
kono
parents:
diff changeset
1256 * pt.c (begin_member_template_processing): New function.
kono
parents:
diff changeset
1257 (end_member_template_processing): Likewise.
kono
parents:
diff changeset
1258 (is_member_template): Likewise.
kono
parents:
diff changeset
1259 (fn_type_unification): Likewise.
kono
parents:
diff changeset
1260 (current_template_parms): Return a vector of all the template
kono
parents:
diff changeset
1261 parms, not just the innermost level of parms.
kono
parents:
diff changeset
1262 (push_template_decl): Deal with the possibility of member
kono
parents:
diff changeset
1263 templates.
kono
parents:
diff changeset
1264 (lookup_template_class): Likewise.
kono
parents:
diff changeset
1265 (uses_template_parms): Likewise.
kono
parents:
diff changeset
1266 (tsubst): Modify processing to TEMPLATE_TYPE_PARM and
kono
parents:
diff changeset
1267 TEMPLATE_CONST_PARM to deal with multiple levels of template
kono
parents:
diff changeset
1268 arguments. Add processing of TEMPLATE_DECL to produce new
kono
parents:
diff changeset
1269 TEMPLATE_DECLs from old ones.
kono
parents:
diff changeset
1270 (do_decl_instantiation): Handle member templates.
kono
parents:
diff changeset
1271
kono
parents:
diff changeset
1272 * search.c (lookup_fnfields_1): Handle member template conversion
kono
parents:
diff changeset
1273 operators.
kono
parents:
diff changeset
1274
kono
parents:
diff changeset
1275 * tree.c (cp_tree_equal): Check the levels, as well as the
kono
parents:
diff changeset
1276 indices, of TEMPLATE_CONST_PARMs.
kono
parents:
diff changeset
1277
kono
parents:
diff changeset
1278 * typeck.c (comptypes): Check the levels, as well as the indices,
kono
parents:
diff changeset
1279 fo TEMPLATE_TYPE_PARMs.
kono
parents:
diff changeset
1280 (build_x_function_call): Treat member templates like member
kono
parents:
diff changeset
1281 functions.
kono
parents:
diff changeset
1282
kono
parents:
diff changeset
1283 Wed Sep 3 11:09:25 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1284
kono
parents:
diff changeset
1285 * typeck.c (c_expand_return): Always convert_for_initialization
kono
parents:
diff changeset
1286 before checking for returning a pointer to local.
kono
parents:
diff changeset
1287
kono
parents:
diff changeset
1288 * pt.c (type_unification): If strict and the function parm doesn't
kono
parents:
diff changeset
1289 use template parms, just compare types.
kono
parents:
diff changeset
1290
kono
parents:
diff changeset
1291 Wed Sep 3 10:35:49 1997 Klaus Espenlaub <kespenla@student.informatik.uni-ulm.de>
kono
parents:
diff changeset
1292
kono
parents:
diff changeset
1293 * method.c (build_overloaded_value): Replace direct call
kono
parents:
diff changeset
1294 to the floating point emulator with REAL_VALUE_TO_DECIMAL macro.
kono
parents:
diff changeset
1295
kono
parents:
diff changeset
1296 Wed Sep 3 00:02:53 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1297
kono
parents:
diff changeset
1298 * typeck.c (convert_arguments): Don't arbitrarily choose the first
kono
parents:
diff changeset
1299 of a set of overloaded functions.
kono
parents:
diff changeset
1300
kono
parents:
diff changeset
1301 Tue Sep 2 12:09:13 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1302
kono
parents:
diff changeset
1303 * lex.c (real_yylex): Don't elide __FUNCTION__.
kono
parents:
diff changeset
1304
kono
parents:
diff changeset
1305 * method.c (build_overload_value): Add in_template parm.
kono
parents:
diff changeset
1306 (build_overload_int): Likewise.
kono
parents:
diff changeset
1307 (build_overload_identifier): Pass it.
kono
parents:
diff changeset
1308
kono
parents:
diff changeset
1309 * decl.c (duplicate_decls): Don't bash a previous template
kono
parents:
diff changeset
1310 definition with a redeclaration.
kono
parents:
diff changeset
1311
kono
parents:
diff changeset
1312 * pt.c (unify): float doesn't match double.
kono
parents:
diff changeset
1313
kono
parents:
diff changeset
1314 * pt.c (do_type_instantiation): Handle getting a _TYPE or a
kono
parents:
diff changeset
1315 TYPE_DECL. Handle getting non-template types.
kono
parents:
diff changeset
1316 * parse.y (explicit_instantiation): Use typespec instead of
kono
parents:
diff changeset
1317 aggr template_type.
kono
parents:
diff changeset
1318
kono
parents:
diff changeset
1319 Tue Sep 2 10:27:08 1997 Richard Henderson <rth@cygnus.com>
kono
parents:
diff changeset
1320
kono
parents:
diff changeset
1321 * typeck.c (build_ptrmemfunc1): Clean up ptr->int cast warnings.
kono
parents:
diff changeset
1322
kono
parents:
diff changeset
1323 Mon Sep 1 13:19:04 1997 Eugene Mamchits <eugin@ips.ras.ru>
kono
parents:
diff changeset
1324
kono
parents:
diff changeset
1325 * call.c (add_builtin_candidate): Add missing TREE_TYPE.
kono
parents:
diff changeset
1326 (compare_ics): Likewise.
kono
parents:
diff changeset
1327
kono
parents:
diff changeset
1328 Mon Sep 1 13:19:04 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1329
kono
parents:
diff changeset
1330 * call.c (joust): Warn about choosing one conversion op over
kono
parents:
diff changeset
1331 another because of 'this' argument when the other return type is
kono
parents:
diff changeset
1332 better.
kono
parents:
diff changeset
1333 (source_type): New fn.
kono
parents:
diff changeset
1334
kono
parents:
diff changeset
1335 * call.c (build_new_op): Strip leading REF_BIND from first operand
kono
parents:
diff changeset
1336 to builtin operator.
kono
parents:
diff changeset
1337
kono
parents:
diff changeset
1338 * decl2.c (mark_vtable_entries): Mark abort_fndecl as used when we
kono
parents:
diff changeset
1339 use its RTL.
kono
parents:
diff changeset
1340
kono
parents:
diff changeset
1341 Thu Aug 28 09:45:23 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1342
kono
parents:
diff changeset
1343 * call.c (null_ptr_cst_p): Remove support for (void*)0.
kono
parents:
diff changeset
1344
kono
parents:
diff changeset
1345 Wed Aug 27 02:03:34 1997 Jeffrey A Law <law@cygnus.com>
kono
parents:
diff changeset
1346
kono
parents:
diff changeset
1347 * typeck.c (expand_target_expr): Make definition match declaration.
kono
parents:
diff changeset
1348
kono
parents:
diff changeset
1349 * class.c (get_basefndecls): Make definition match declaration.
kono
parents:
diff changeset
1350
kono
parents:
diff changeset
1351 Mon Aug 25 14:30:02 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1352
kono
parents:
diff changeset
1353 * input.c (sub_getch): Eventually give up and release the input file.
kono
parents:
diff changeset
1354
kono
parents:
diff changeset
1355 * decl.c (cp_finish_decl): If #p i/i, put inline statics in the
kono
parents:
diff changeset
1356 right place.
kono
parents:
diff changeset
1357
kono
parents:
diff changeset
1358 * call.c (joust): Tweak message.
kono
parents:
diff changeset
1359
kono
parents:
diff changeset
1360 Sat Aug 23 18:02:59 1997 Mark Mitchell <mmitchell@usa.net>
kono
parents:
diff changeset
1361
kono
parents:
diff changeset
1362 * error.c (type_as_string): Put const/volatile on template type
kono
parents:
diff changeset
1363 parameters where appropriate.
kono
parents:
diff changeset
1364
kono
parents:
diff changeset
1365 Sat Aug 23 17:47:22 1997 Jeffrey A Law <law@cygnus.com>
kono
parents:
diff changeset
1366
kono
parents:
diff changeset
1367 * call.c (strictly_better): Make arguments unsigned ints.
kono
parents:
diff changeset
1368
kono
parents:
diff changeset
1369 Thu Aug 21 18:48:44 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1370
kono
parents:
diff changeset
1371 * lex.c (real_yylex): Refer to __complex instead of complex.
kono
parents:
diff changeset
1372
kono
parents:
diff changeset
1373 Thu Aug 21 22:25:46 1997 J"orn Rennecke <amylaar@cygnus.co.uk>
kono
parents:
diff changeset
1374
kono
parents:
diff changeset
1375 * lex.c (real_yylex): Don't use getc directly.
kono
parents:
diff changeset
1376
kono
parents:
diff changeset
1377 Wed Aug 20 17:25:08 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1378
kono
parents:
diff changeset
1379 * call.c (is_subseq): Don't try to be clever.
kono
parents:
diff changeset
1380
kono
parents:
diff changeset
1381 Wed Aug 20 03:13:36 1997 H.J. Lu (hjl@gnu.ai.mit.edu)
kono
parents:
diff changeset
1382
kono
parents:
diff changeset
1383 * parse.y, pt.c: Include "except.h".
kono
parents:
diff changeset
1384 * call.c, class.c, class.h, cp-tree.h, cvt.c, decl.c, decl2.c,
kono
parents:
diff changeset
1385 error.c, except.c, expr.c, friend.c, g++spec.c, init.c, input.c,
kono
parents:
diff changeset
1386 lex.c, lex.h, method.c, parse.y, pt.c, repo.c, rtti.c, search.c,
kono
parents:
diff changeset
1387 sig.c, spew.c, tree.c, typeck.c, typeck2.c, xref.c: Finish
kono
parents:
diff changeset
1388 prototyping.
kono
parents:
diff changeset
1389
kono
parents:
diff changeset
1390 Wed Aug 20 01:34:40 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1391
kono
parents:
diff changeset
1392 * decl2.c (mark_vtable_entries): Instead of replacing pure
kono
parents:
diff changeset
1393 virtuals with a reference to __pure_virtual, copy the decl and
kono
parents:
diff changeset
1394 change the RTL.
kono
parents:
diff changeset
1395
kono
parents:
diff changeset
1396 Tue Aug 19 02:26:07 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1397
kono
parents:
diff changeset
1398 * pt.c (lookup_nested_type_by_name): Handle typedef wierdness.
kono
parents:
diff changeset
1399
kono
parents:
diff changeset
1400 * typeck2.c (my_friendly_abort): Report bugs to egcs-bugs@cygnus.com.
kono
parents:
diff changeset
1401
kono
parents:
diff changeset
1402 * pt.c (instantiate_class_template): Call repo_template_used
kono
parents:
diff changeset
1403 before finish_prevtable_vardecl.
kono
parents:
diff changeset
1404
kono
parents:
diff changeset
1405 * call.c (is_subseq): New fn.
kono
parents:
diff changeset
1406 (compare_ics): Use it.
kono
parents:
diff changeset
1407
kono
parents:
diff changeset
1408 * repo.c (finish_repo): Don't crash on no args.
kono
parents:
diff changeset
1409
kono
parents:
diff changeset
1410 * parse.y (named_complex_class_head_sans_basetype): Handle
kono
parents:
diff changeset
1411 explicit global scope.
kono
parents:
diff changeset
1412 * decl2.c (handle_class_head): New fn.
kono
parents:
diff changeset
1413
kono
parents:
diff changeset
1414 * pt.c (unify): Add CONST_DECL case.
kono
parents:
diff changeset
1415
kono
parents:
diff changeset
1416 Thu Aug 14 10:05:13 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1417
kono
parents:
diff changeset
1418 * rtti.c (permanent_obstack): Fix decl to not be a pointer.
kono
parents:
diff changeset
1419
kono
parents:
diff changeset
1420 * cp-tree.h (report_type_mismatch): Add prototype.
kono
parents:
diff changeset
1421 * call.c (build_overload_call_real): Remove erroneous fourth
kono
parents:
diff changeset
1422 argument to report_type_mismatch.
kono
parents:
diff changeset
1423 (build_user_type_conversion_1): Remove erroneous second arg to
kono
parents:
diff changeset
1424 tourney.
kono
parents:
diff changeset
1425 (build_new_function_call): Likewise.
kono
parents:
diff changeset
1426 (build_object_call): Likewise.
kono
parents:
diff changeset
1427 (build_new_op): Likewise.
kono
parents:
diff changeset
1428 (build_new_method_call): Likewise.
kono
parents:
diff changeset
1429
kono
parents:
diff changeset
1430 Wed Aug 13 19:19:25 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1431
kono
parents:
diff changeset
1432 * error.c (dump_decl): Don't bother processing a function with no
kono
parents:
diff changeset
1433 DECL_LANG_SPECIFIC.
kono
parents:
diff changeset
1434
kono
parents:
diff changeset
1435 * method.c (emit_thunk): Call init_function_start in the macro case.
kono
parents:
diff changeset
1436
kono
parents:
diff changeset
1437 Wed Aug 13 10:46:19 1997 H.J. Lu (hjl@gnu.ai.mit.edu)
kono
parents:
diff changeset
1438
kono
parents:
diff changeset
1439 * decl2.c (DEFAULT_VTABLE_THUNKS): Define to be 0 if not
kono
parents:
diff changeset
1440 defined and used to set flag_vtable_thunks.
kono
parents:
diff changeset
1441
kono
parents:
diff changeset
1442 Tue Aug 12 20:13:57 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1443
kono
parents:
diff changeset
1444 * parse.y: Don't clear the inlines from their obstack until they've
kono
parents:
diff changeset
1445 all been processed.
kono
parents:
diff changeset
1446
kono
parents:
diff changeset
1447 * decl.c (duplicate_decls): Don't complain about exception
kono
parents:
diff changeset
1448 specification mismatch if flag_exceptions is off.
kono
parents:
diff changeset
1449
kono
parents:
diff changeset
1450 Mon Aug 11 15:01:56 1997 Marc Lehmann <pcg@goof.com>
kono
parents:
diff changeset
1451
kono
parents:
diff changeset
1452 * Make-lang.in (c++.distclean): Remove g++.c on make distclean.
kono
parents:
diff changeset
1453
kono
parents:
diff changeset
1454 Sun Aug 10 12:06:09 1997 Paul Eggert <eggert@twinsun.com>
kono
parents:
diff changeset
1455
kono
parents:
diff changeset
1456 * cp-tree.h: Replace STDIO_PROTO with PROTO in include files.
kono
parents:
diff changeset
1457 * cvt.c, error.c, except.c, expr.c, friend.c, init.c, rtti.c:
kono
parents:
diff changeset
1458 Include <stdio.h> before include files that formerly used STDIO_PROTO.
kono
parents:
diff changeset
1459
kono
parents:
diff changeset
1460 * decl.c, g++spec.c, lex.c, method.c, repo.c:
kono
parents:
diff changeset
1461 Include "config.h" first, as per autoconf manual.
kono
parents:
diff changeset
1462
kono
parents:
diff changeset
1463 Fri Aug 8 11:47:48 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1464
kono
parents:
diff changeset
1465 * decl.c (duplicate_decls): Tweak wording.
kono
parents:
diff changeset
1466 * lex.c (do_pending_defargs): Don't die if we see a default arg
kono
parents:
diff changeset
1467 that isn't a DEFAULT_ARG.
kono
parents:
diff changeset
1468 * error.c (dump_expr): Handle DEFAULT_ARG.
kono
parents:
diff changeset
1469
kono
parents:
diff changeset
1470 * decl2.c (lang_decode_option): Handle -fhandle-exceptions.
kono
parents:
diff changeset
1471 * lang-options.h: Add -fhandle-exceptions.
kono
parents:
diff changeset
1472
kono
parents:
diff changeset
1473 * class.c (build_vtable): Vtables are artificial.
kono
parents:
diff changeset
1474 (prepare_fresh_vtable): Likewise.
kono
parents:
diff changeset
1475
kono
parents:
diff changeset
1476 Wed Aug 6 11:02:36 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1477
kono
parents:
diff changeset
1478 * cvt.c (ocp_convert): After converting to the target type, set
kono
parents:
diff changeset
1479 LOOKUP_NO_CONVERSION.
kono
parents:
diff changeset
1480
kono
parents:
diff changeset
1481 * call.c (joust): Warn about potentially confusing promotion rules
kono
parents:
diff changeset
1482 with -Wsign-promo.
kono
parents:
diff changeset
1483 * cp-tree.h, lang-options.h, decl2.c: Support -Wsign-promo.
kono
parents:
diff changeset
1484
kono
parents:
diff changeset
1485 Tue Aug 5 15:15:07 1997 Michael Meissner <meissner@cygnus.com>
kono
parents:
diff changeset
1486
kono
parents:
diff changeset
1487 * exception.cc: Declare __terminate_func with noreturn attribute.
kono
parents:
diff changeset
1488
kono
parents:
diff changeset
1489 Fri Aug 1 03:18:15 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1490
kono
parents:
diff changeset
1491 * parse.y: Break out eat_saved_input, handle errors.
kono
parents:
diff changeset
1492 (function_try_block): Use compstmt instead of compstmt_or_error.
kono
parents:
diff changeset
1493
kono
parents:
diff changeset
1494 Thu Jul 31 17:14:04 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1495
kono
parents:
diff changeset
1496 * tree.c (build_cplus_new): Don't set TREE_ADDRESSABLE.
kono
parents:
diff changeset
1497
kono
parents:
diff changeset
1498 Fri Jul 4 01:45:16 1997 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
kono
parents:
diff changeset
1499
kono
parents:
diff changeset
1500 * Make-lang.in (cplib2.txt, cplib2.ready): Instead of checking for
kono
parents:
diff changeset
1501 existence of cc1plus check whether $(LANGUAGES) contains C++.
kono
parents:
diff changeset
1502
kono
parents:
diff changeset
1503 Wed Jul 30 13:04:21 1997 Andreas Schwab <schwab@issan.informatik.uni-dortmund.de>
kono
parents:
diff changeset
1504
kono
parents:
diff changeset
1505 * method.c (do_build_copy_constructor): When copying an anonymous
kono
parents:
diff changeset
1506 union member loop around to handle nested anonymous unions. Use
kono
parents:
diff changeset
1507 the offset of the member relative to the outer structure, not the
kono
parents:
diff changeset
1508 union.
kono
parents:
diff changeset
1509
kono
parents:
diff changeset
1510 Tue Jul 29 21:17:29 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1511
kono
parents:
diff changeset
1512 * call.c (resolve_args): New fn.
kono
parents:
diff changeset
1513 (build_new_function_call): Use it.
kono
parents:
diff changeset
1514 (build_object_call): Likewise.
kono
parents:
diff changeset
1515 (build_new_method_call): Likewise.
kono
parents:
diff changeset
1516
kono
parents:
diff changeset
1517 Mon Jul 28 16:02:36 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1518
kono
parents:
diff changeset
1519 * call.c (build_over_call): tsubst all default parms from templates.
kono
parents:
diff changeset
1520
kono
parents:
diff changeset
1521 Wed Jul 23 13:36:25 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1522
kono
parents:
diff changeset
1523 * decl.c (struct cp_function): Add static_labelno.
kono
parents:
diff changeset
1524 (push_cp_function_context): Save it.
kono
parents:
diff changeset
1525 (pop_cp_function_context): Restore it.
kono
parents:
diff changeset
1526
kono
parents:
diff changeset
1527 Tue Jul 22 14:43:29 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1528
kono
parents:
diff changeset
1529 * typeck.c (build_component_ref_1): Convert from reference.
kono
parents:
diff changeset
1530
kono
parents:
diff changeset
1531 Tue Jul 22 11:06:23 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1532
kono
parents:
diff changeset
1533 * parse.y (current_declspecs, prefix_attributes): Initialize to
kono
parents:
diff changeset
1534 NULL_TREE.
kono
parents:
diff changeset
1535
kono
parents:
diff changeset
1536 * parse.y (initdcl0): Make sure CURRENT_DECLSPECS is non-nil
kono
parents:
diff changeset
1537 before we try to force it to be a TREE_LIST.
kono
parents:
diff changeset
1538 (decl): Make sure $1.t is non-nil.
kono
parents:
diff changeset
1539
kono
parents:
diff changeset
1540 Sun Jul 20 11:53:07 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1541
kono
parents:
diff changeset
1542 * pt.c (uses_template_parms): Handle template first-parse codes.
kono
parents:
diff changeset
1543
kono
parents:
diff changeset
1544 * decl.c (cp_finish_decl): Only warn about user-defined statics.
kono
parents:
diff changeset
1545
kono
parents:
diff changeset
1546 Fri Jul 18 17:56:08 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1547
kono
parents:
diff changeset
1548 * pt.c (unify): Handle BOOLEAN_TYPE.
kono
parents:
diff changeset
1549
kono
parents:
diff changeset
1550 * cp-tree.h: Lose PARM_DEFAULT_FROM_TEMPLATE.
kono
parents:
diff changeset
1551 * pt.c (tsubst): Don't set it.
kono
parents:
diff changeset
1552 * call.c (build_over_call): Use uses_template_parms.
kono
parents:
diff changeset
1553
kono
parents:
diff changeset
1554 Thu Jul 17 18:06:30 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1555
kono
parents:
diff changeset
1556 * method.c (build_overload_nested_name): Use static_labelno
kono
parents:
diff changeset
1557 instead of var_labelno.
kono
parents:
diff changeset
1558 (build_qualified_name): New fn.
kono
parents:
diff changeset
1559 (build_overload_name): Split out from here.
kono
parents:
diff changeset
1560 (build_static_name): Use build_qualified_name.
kono
parents:
diff changeset
1561 * decl.c (cp_finish_decl): Statics in extern inline functions
kono
parents:
diff changeset
1562 have comdat linkage.
kono
parents:
diff changeset
1563 (start_function): Initialize static_labelno.
kono
parents:
diff changeset
1564
kono
parents:
diff changeset
1565 Thu Jul 17 11:20:17 1997 Benjamin Kosnik <bkoz@rhino.cygnus.com>
kono
parents:
diff changeset
1566
kono
parents:
diff changeset
1567 * class.c (finish_struct_methods): Add check of warn_ctor_dtor_privacy
kono
parents:
diff changeset
1568 before "all member functions in class [] are private".
kono
parents:
diff changeset
1569
kono
parents:
diff changeset
1570 Wed Jul 16 23:47:08 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1571
kono
parents:
diff changeset
1572 * lex.c (do_scoped_id): convert_from_reference.
kono
parents:
diff changeset
1573 * init.c (build_offset_ref): Likewise.
kono
parents:
diff changeset
1574
kono
parents:
diff changeset
1575 Wed Jul 16 12:34:29 1997 Benjamin Kosnik <bkoz@lisa.cygnus.com>
kono
parents:
diff changeset
1576
kono
parents:
diff changeset
1577 * error.c (dump_expr): Check TREE_OPERAND before dump_expr_list.
kono
parents:
diff changeset
1578
kono
parents:
diff changeset
1579 Mon Jul 14 03:23:46 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1580
kono
parents:
diff changeset
1581 * typeck.c (get_member_function_from_ptrfunc): Promote index
kono
parents:
diff changeset
1582 before saving it.
kono
parents:
diff changeset
1583
kono
parents:
diff changeset
1584 Sun Jul 13 00:11:52 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1585
kono
parents:
diff changeset
1586 * tree.c (layout_basetypes): Move non-virtual destructor warning.
kono
parents:
diff changeset
1587 * decl.c (xref_basetypes): Remove non-virtual destructor warning.
kono
parents:
diff changeset
1588
kono
parents:
diff changeset
1589 Sat Jul 12 12:47:12 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1590
kono
parents:
diff changeset
1591 * decl.c (grokdeclarator): Call add_defarg_fn for the function
kono
parents:
diff changeset
1592 type, too.
kono
parents:
diff changeset
1593 * lex.c (add_defarg_fn): Adjust.
kono
parents:
diff changeset
1594 (do_pending_defargs): Adjust. Don't skip the first parm.
kono
parents:
diff changeset
1595
kono
parents:
diff changeset
1596 Fri Jul 11 01:39:50 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1597
kono
parents:
diff changeset
1598 * decl.c (build_enumerator): Global enumerators are also readonly.
kono
parents:
diff changeset
1599
kono
parents:
diff changeset
1600 * rtti.c (build_dynamic_cast_1): Renamed from build_dynamic_cast.
kono
parents:
diff changeset
1601 (build_dynamic_cast): Call it and convert_from_reference.
kono
parents:
diff changeset
1602
kono
parents:
diff changeset
1603 * lex.c (add_defarg_fn): New fn.
kono
parents:
diff changeset
1604 (snarf_defarg): Don't add to defarg_types.
kono
parents:
diff changeset
1605 (do_pending_defargs): Lose defarg_types. All fns we process now
kono
parents:
diff changeset
1606 have defargs.
kono
parents:
diff changeset
1607 * decl.c (grokfndecl): Call add_defarg_fn.
kono
parents:
diff changeset
1608
kono
parents:
diff changeset
1609 * Makefile.in (CONFLICTS): Expect 18 s/r conflicts.
kono
parents:
diff changeset
1610 * cp-tree.def: Add DEFAULT_ARG.
kono
parents:
diff changeset
1611 * spew.c (yylex): Call snarf_defarg as appropriate.
kono
parents:
diff changeset
1612 * parse.y: New tokens DEFARG and DEFARG_MARKER.
kono
parents:
diff changeset
1613 (defarg_again, pending_defargs, defarg, defarg1): New rules.
kono
parents:
diff changeset
1614 (structsp): Use pending_defargs.
kono
parents:
diff changeset
1615 (parms, full_parm): Use defarg.
kono
parents:
diff changeset
1616 * lex.c (init_lex): Initialize inline_text_firstobj.
kono
parents:
diff changeset
1617 (do_pending_inlines): Never pass the obstack to feed_input.
kono
parents:
diff changeset
1618 (process_next_inline): Call end_input instead of restore_pending_input.
kono
parents:
diff changeset
1619 (clear_inline_text_obstack, reinit_parse_for_expr, do_pending_defargs,
kono
parents:
diff changeset
1620 finish_defarg, feed_defarg, snarf_defarg, maybe_snarf_defarg): New fns.
kono
parents:
diff changeset
1621 * input.c (end_input): New fn.
kono
parents:
diff changeset
1622 (sub_getch): At the end of some fed input, just keep returning EOF
kono
parents:
diff changeset
1623 until someone calls end_input.
kono
parents:
diff changeset
1624 Remove 'obstack' field from struct input_source.
kono
parents:
diff changeset
1625 * decl.c (grokparms): Handle DEFAULT_ARG.
kono
parents:
diff changeset
1626 (replace_defarg): New fn.
kono
parents:
diff changeset
1627 * cp-tree.h (DEFARG_LENGTH, DEFARG_POINTER): New macros.
kono
parents:
diff changeset
1628
kono
parents:
diff changeset
1629 Wed Jul 9 13:44:12 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1630
kono
parents:
diff changeset
1631 * call.c (implicit_conversion): If nothing else works, try binding
kono
parents:
diff changeset
1632 an rvalue to a reference.
kono
parents:
diff changeset
1633
kono
parents:
diff changeset
1634 Wed Jul 9 13:04:38 1997 Geoffrey Noer <noer@cygnus.com>
kono
parents:
diff changeset
1635
kono
parents:
diff changeset
1636 * decl.c (init_decl_processing): Fix Jun 30 patch -- move
kono
parents:
diff changeset
1637 ifndef for Cygwin32 to include SIGSEGV.
kono
parents:
diff changeset
1638
kono
parents:
diff changeset
1639 Thu Jul 3 01:44:05 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1640
kono
parents:
diff changeset
1641 * class.c (finish_struct_1): Only complain about pointers without
kono
parents:
diff changeset
1642 copy stuff if there are any constructors.
kono
parents:
diff changeset
1643
kono
parents:
diff changeset
1644 * rtti.c (build_dynamic_cast): Call complete_type on the types.
kono
parents:
diff changeset
1645
kono
parents:
diff changeset
1646 * decl.c (grokfndecl): If the function we chose doesn't actually
kono
parents:
diff changeset
1647 match, die.
kono
parents:
diff changeset
1648
kono
parents:
diff changeset
1649 * decl2.c (grokclassfn): Don't specify 'const int' for the
kono
parents:
diff changeset
1650 artificial destructor parm.
kono
parents:
diff changeset
1651
kono
parents:
diff changeset
1652 * pt.c (type_unification): If we are called recursively, nothing
kono
parents:
diff changeset
1653 decays.
kono
parents:
diff changeset
1654
kono
parents:
diff changeset
1655 Mon Jun 30 17:53:21 1997 Geoffrey Noer <noer@cygnus.com>
kono
parents:
diff changeset
1656
kono
parents:
diff changeset
1657 * decl.c (init_decl_processing): Stop trying to catch signals
kono
parents:
diff changeset
1658 other than SIGABRT since the Cygwin32 library doesn't support
kono
parents:
diff changeset
1659 them correctly yet. This fixes a situation in which g++ causes
kono
parents:
diff changeset
1660 a hang on SIGSEGVs and other such signals in our Win32-hosted
kono
parents:
diff changeset
1661 tools.
kono
parents:
diff changeset
1662
kono
parents:
diff changeset
1663 Mon Jun 30 14:50:01 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1664
kono
parents:
diff changeset
1665 * tree.c (mapcar, case CALL_EXPR): Handle all the parse node data.
kono
parents:
diff changeset
1666
kono
parents:
diff changeset
1667 Fri Jun 27 15:18:49 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1668
kono
parents:
diff changeset
1669 * typeck2.c (store_init_value): Always return the value if our
kono
parents:
diff changeset
1670 type needs constructing.
kono
parents:
diff changeset
1671
kono
parents:
diff changeset
1672 * method.c (hack_identifier): Convert class statics from
kono
parents:
diff changeset
1673 reference, too.
kono
parents:
diff changeset
1674
kono
parents:
diff changeset
1675 Thu Jun 26 11:44:46 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1676
kono
parents:
diff changeset
1677 * Make-lang.in (cplib2.ready): Add $(LANGUAGES) dependency.
kono
parents:
diff changeset
1678
kono
parents:
diff changeset
1679 Thu Jun 19 16:49:28 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1680
kono
parents:
diff changeset
1681 * typeck.c (c_expand_return): Make sure we clean up temporaries at
kono
parents:
diff changeset
1682 the end of return x;
kono
parents:
diff changeset
1683
kono
parents:
diff changeset
1684 Thu Jun 19 12:28:43 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1685
kono
parents:
diff changeset
1686 * lex.c (check_for_missing_semicolon): Also check for CV_QUALIFIER.
kono
parents:
diff changeset
1687
kono
parents:
diff changeset
1688 Tue Jun 17 18:35:57 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1689
kono
parents:
diff changeset
1690 * except.c (expand_builtin_throw): Add support
kono
parents:
diff changeset
1691 -fno-sjlj-exceptions -fPIC exception handling on the SPARC.
kono
parents:
diff changeset
1692
kono
parents:
diff changeset
1693 Mon Jun 16 01:24:37 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1694
kono
parents:
diff changeset
1695 * repo.c (extract_string): Null-terminate.
kono
parents:
diff changeset
1696
kono
parents:
diff changeset
1697 * cp-tree.h (TI_SPEC_INFO): New macro.
kono
parents:
diff changeset
1698 (CLASSTYPE_TI_SPEC_INFO): New macro.
kono
parents:
diff changeset
1699 * pt.c (push_template_decl): Correctly determine # of template parms
kono
parents:
diff changeset
1700 for partial specs.
kono
parents:
diff changeset
1701
kono
parents:
diff changeset
1702 * call.c (compare_ics): Really fix 'this' conversions.
kono
parents:
diff changeset
1703
kono
parents:
diff changeset
1704 * pt.c (do_decl_instantiation): Don't crash on explicit inst of
kono
parents:
diff changeset
1705 non-template fn.
kono
parents:
diff changeset
1706
kono
parents:
diff changeset
1707 * pt.c (push_template_decl): Complain about mismatch in # of
kono
parents:
diff changeset
1708 template parms between a class template and a member template.
kono
parents:
diff changeset
1709
kono
parents:
diff changeset
1710 Sun Jun 15 02:38:20 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1711
kono
parents:
diff changeset
1712 * method.c (synthesize_method): You can't call
kono
parents:
diff changeset
1713 function_cannot_inline_p after finish_function.
kono
parents:
diff changeset
1714 * decl.c (finish_function): Turn on flag_inline_functions and turn
kono
parents:
diff changeset
1715 off DECL_INLINE before handing a synthesized method to the
kono
parents:
diff changeset
1716 backend.
kono
parents:
diff changeset
1717
kono
parents:
diff changeset
1718 Thu Jun 12 17:35:28 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1719
kono
parents:
diff changeset
1720 * method.c (synthesize_method): Remove July 30 change to never set
kono
parents:
diff changeset
1721 DECL_INLINE if at_eof.
kono
parents:
diff changeset
1722
kono
parents:
diff changeset
1723 Thu Jun 12 15:25:08 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1724
kono
parents:
diff changeset
1725 * xref.c (GNU_xref_member): Ensure that the node has a
kono
parents:
diff changeset
1726 decl_lang_specific part before checking DECL_FRIEND_P.
kono
parents:
diff changeset
1727
kono
parents:
diff changeset
1728 Thu Jun 12 12:36:05 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1729
kono
parents:
diff changeset
1730 * pt.c (instantiate_class_template): Diagnose non-class types used
kono
parents:
diff changeset
1731 as bases.
kono
parents:
diff changeset
1732
kono
parents:
diff changeset
1733 Wed Jun 11 17:33:40 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1734
kono
parents:
diff changeset
1735 * typeck.c (build_conditional_expr): Use convert_for_initialization
kono
parents:
diff changeset
1736 instead of convert_and_check.
kono
parents:
diff changeset
1737
kono
parents:
diff changeset
1738 Wed Jun 11 12:31:33 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1739
kono
parents:
diff changeset
1740 * parse.y (typespec): Don't pedwarn for typeof.
kono
parents:
diff changeset
1741
kono
parents:
diff changeset
1742 Tue Jun 10 00:22:09 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1743
kono
parents:
diff changeset
1744 * repo.c (finish_repo): Only check changes if we would write a
kono
parents:
diff changeset
1745 repo file.
kono
parents:
diff changeset
1746
kono
parents:
diff changeset
1747 * call.c (compare_ics): Fix handling of 'this' conversions.
kono
parents:
diff changeset
1748
kono
parents:
diff changeset
1749 * pt.c (do_decl_instantiation): Support static data too. Rename
kono
parents:
diff changeset
1750 from do_function_instantiation.
kono
parents:
diff changeset
1751 * cp-tree.h: Adjust.
kono
parents:
diff changeset
1752 * parse.y: Adjust.
kono
parents:
diff changeset
1753
kono
parents:
diff changeset
1754 * repo.c (extract_string): New fn.
kono
parents:
diff changeset
1755 (get_base_filename): Use it.
kono
parents:
diff changeset
1756 (init_repo): Compare old args with current args.
kono
parents:
diff changeset
1757
kono
parents:
diff changeset
1758 Mon Jun 9 14:25:30 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1759
kono
parents:
diff changeset
1760 * Makefile.in, Make-lang.in: Protect C-ls with a comment
kono
parents:
diff changeset
1761 character, idea from Paul Eggert <eggert@twinsun.com>.
kono
parents:
diff changeset
1762
kono
parents:
diff changeset
1763 Mon Jun 9 01:52:03 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1764
kono
parents:
diff changeset
1765 * typeck.c (c_expand_return): Be more persistent in looking for
kono
parents:
diff changeset
1766 returned temps.
kono
parents:
diff changeset
1767
kono
parents:
diff changeset
1768 * cvt.c (build_up_reference): Use NOP_EXPR for switching from
kono
parents:
diff changeset
1769 pointer to reference.
kono
parents:
diff changeset
1770
kono
parents:
diff changeset
1771 * class.c (build_vbase_path): Don't do anything if PATH has no steps.
kono
parents:
diff changeset
1772
kono
parents:
diff changeset
1773 Sun Jun 8 03:07:05 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1774
kono
parents:
diff changeset
1775 * init.c (build_member_call, build_offset_ref):
kono
parents:
diff changeset
1776 Use do_scoped_id instead of do_identifier.
kono
parents:
diff changeset
1777
kono
parents:
diff changeset
1778 * cvt.c (convert): Remove bogosity.
kono
parents:
diff changeset
1779
kono
parents:
diff changeset
1780 Sat Jun 7 20:50:17 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1781
kono
parents:
diff changeset
1782 * cvt.c (build_up_reference): Do checks of ARGTYPE and
kono
parents:
diff changeset
1783 TARGET_TYPE before trying to use get_binfo.
kono
parents:
diff changeset
1784
kono
parents:
diff changeset
1785 Fri Jun 6 17:36:39 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1786
kono
parents:
diff changeset
1787 * cvt.c (build_up_reference): Call get_binfo to get access control.
kono
parents:
diff changeset
1788
kono
parents:
diff changeset
1789 * decl2.c (import_export_decl): If we don't support weaks, leave
kono
parents:
diff changeset
1790 statics undefined.
kono
parents:
diff changeset
1791
kono
parents:
diff changeset
1792 Fri Jun 6 15:55:49 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1793
kono
parents:
diff changeset
1794 * except.c (expand_builtin_throw): Add support for machines that
kono
parents:
diff changeset
1795 cannot access globals after throw's epilogue when
kono
parents:
diff changeset
1796 -fno-sjlj-exceptions is used.
kono
parents:
diff changeset
1797
kono
parents:
diff changeset
1798 Thu Jun 5 16:28:43 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1799
kono
parents:
diff changeset
1800 * parse.y: 'std::' becomes '::'.
kono
parents:
diff changeset
1801 * lex.c (real_yylex): Remove 'namespace' warning.
kono
parents:
diff changeset
1802 * init.c (build_member_call): Ignore 'std::'.
kono
parents:
diff changeset
1803 (build_offset_ref): Likewise.
kono
parents:
diff changeset
1804 * decl2.c (do_using_directive): Ignore 'using namespace std;'.
kono
parents:
diff changeset
1805 (do_toplevel_using_decl): Ignore 'using std::whatever'.
kono
parents:
diff changeset
1806 * decl.c (push_namespace): Just sorry.
kono
parents:
diff changeset
1807 (pop_namespace): Nop.
kono
parents:
diff changeset
1808 (init_decl_processing): Declare std namespace.
kono
parents:
diff changeset
1809
kono
parents:
diff changeset
1810 Tue Jun 3 18:08:23 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1811
kono
parents:
diff changeset
1812 * search.c (push_class_decls): A name which ambiguously refers to
kono
parents:
diff changeset
1813 several instantiations of the same template just refers to the
kono
parents:
diff changeset
1814 template.
kono
parents:
diff changeset
1815
kono
parents:
diff changeset
1816 Tue Jun 3 12:30:40 1997 Benjamin Kosnik <bkoz@cirdan.cygnus.com>
kono
parents:
diff changeset
1817
kono
parents:
diff changeset
1818 * decl.c (build_enumerator): Fix problem with unsigned long
kono
parents:
diff changeset
1819 enumerated values being smashed to ints, causing overflow
kono
parents:
diff changeset
1820 when computing next enumerated value (for enum values around
kono
parents:
diff changeset
1821 MAX_VAL).
kono
parents:
diff changeset
1822
kono
parents:
diff changeset
1823 Mon Jun 2 17:40:56 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1824
kono
parents:
diff changeset
1825 * typeck.c (build_component_ref): Only call mark_used on a decl.
kono
parents:
diff changeset
1826
kono
parents:
diff changeset
1827 Thu May 29 15:54:17 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1828
kono
parents:
diff changeset
1829 * typeck.c (build_c_cast): Make the check for a ptr to function
kono
parents:
diff changeset
1830 more specific before possible default_conversion call.
kono
parents:
diff changeset
1831
kono
parents:
diff changeset
1832 Thu May 29 13:02:06 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1833
kono
parents:
diff changeset
1834 * except.c (expand_exception_blocks): Simplify and fix and make
kono
parents:
diff changeset
1835 sure we don't end a region in a sequence, as expand_end_bindings
kono
parents:
diff changeset
1836 doesn't like it.
kono
parents:
diff changeset
1837
kono
parents:
diff changeset
1838 Wed May 28 17:08:03 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1839
kono
parents:
diff changeset
1840 * except.c (init_exception_processing): Mark terminate as not
kono
parents:
diff changeset
1841 returning so that the optimizer can optimize better.
kono
parents:
diff changeset
1842
kono
parents:
diff changeset
1843 Tue May 27 19:49:19 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1844
kono
parents:
diff changeset
1845 * cvt.c (convert): Don't do any extra work, if we can avoid it
kono
parents:
diff changeset
1846 easily.
kono
parents:
diff changeset
1847
kono
parents:
diff changeset
1848 Tue May 27 18:21:47 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1849
kono
parents:
diff changeset
1850 * *.[chy]: Change cp_convert to ocp_convert, change convert to
kono
parents:
diff changeset
1851 cp_convert. convert is now reserved for the backend, and doesn't
kono
parents:
diff changeset
1852 have the semantics a frontend person should ever want.
kono
parents:
diff changeset
1853
kono
parents:
diff changeset
1854 Fri May 23 10:58:31 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1855
kono
parents:
diff changeset
1856 * lang-specs.h: Define __EXCEPTIONS if exceptions are enabled.
kono
parents:
diff changeset
1857 Lose -traditional support.
kono
parents:
diff changeset
1858
kono
parents:
diff changeset
1859 Thu May 22 15:41:28 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1860
kono
parents:
diff changeset
1861 * rtti.c (get_tinfo_var): Use TYPE_PRECISION (sizetype).
kono
parents:
diff changeset
1862
kono
parents:
diff changeset
1863 * parse.y (self_reference): Do it for templates, too.
kono
parents:
diff changeset
1864 * class.c (pushclass): Don't overload_template_name; the alias
kono
parents:
diff changeset
1865 generated by build_self_reference serves the same purpose.
kono
parents:
diff changeset
1866
kono
parents:
diff changeset
1867 * tree.c (list_hash): Make static, take more args.
kono
parents:
diff changeset
1868 (list_hash_lookup): Likewise.
kono
parents:
diff changeset
1869 (list_hash_add): Make static.
kono
parents:
diff changeset
1870 (list_hash_canon): Lose.
kono
parents:
diff changeset
1871 (hash_tree_cons): Only build a new node if one isn't already in the
kono
parents:
diff changeset
1872 hashtable.
kono
parents:
diff changeset
1873 (hash_tree_chain): Use hash_tree_cons.
kono
parents:
diff changeset
1874 * cp-tree.h: Adjust.
kono
parents:
diff changeset
1875 * decl.c (grokfndecl): Just check IDENTIFIER_GLOBAL_VALUE instead
kono
parents:
diff changeset
1876 of calling lookup_name.
kono
parents:
diff changeset
1877
kono
parents:
diff changeset
1878 Wed May 21 18:24:19 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1879
kono
parents:
diff changeset
1880 * pt.c (instantiate_class_template): TYPE_VALUES for an enum
kono
parents:
diff changeset
1881 doesn't refer to the CONST_DECLs.
kono
parents:
diff changeset
1882
kono
parents:
diff changeset
1883 Tue May 20 21:09:32 1997 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1884
kono
parents:
diff changeset
1885 * rtti.c (get_tinfo_var): Either INT_TYPE_SIZE or 32, whichever
kono
parents:
diff changeset
1886 is bigger.
kono
parents:
diff changeset
1887 (expand_class_desc): Convert the last argument to a sizetype.
kono
parents:
diff changeset
1888
kono
parents:
diff changeset
1889 Tue May 20 13:55:57 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1890
kono
parents:
diff changeset
1891 * gxx.gperf (__complex, __complex__, __imag, __imag__, __real,
kono
parents:
diff changeset
1892 __real__): Add reswords.
kono
parents:
diff changeset
1893 * hash.h: Regenerate.
kono
parents:
diff changeset
1894 * lex.h (rid): Add RID_COMPLEX.
kono
parents:
diff changeset
1895 (RID_LAST_MODIFIER): Set to RID_COMPLEX.
kono
parents:
diff changeset
1896 * lex.c (init_lex): Add building of RID_COMPLEX.
kono
parents:
diff changeset
1897 (real_yylex): General cleanup in line with what c-lex.c also has,
kono
parents:
diff changeset
1898 sans the cruft for traditional; add handling of SPEC_IMAG, complex
kono
parents:
diff changeset
1899 types, and imaginary numeric constants.
kono
parents:
diff changeset
1900 * parse.y (REALPART, IMAGPART): Add tokens.
kono
parents:
diff changeset
1901 (unary_expr): Add REALPART and IMAGPART rules.
kono
parents:
diff changeset
1902 * cp-tree.h (complex_{integer,float,double,long}_type_node): Declare.
kono
parents:
diff changeset
1903 * decl.c (complex_{integer,float,double,long}_type_node): Define
kono
parents:
diff changeset
1904 types.
kono
parents:
diff changeset
1905 (init_decl_processing): Set up the types.
kono
parents:
diff changeset
1906 (grokdeclarator): Add handling of RID_COMPLEX. Set and use
kono
parents:
diff changeset
1907 DEFAULTED_INT instead of EXPLICIT_INT when we default to int type.
kono
parents:
diff changeset
1908 * call.c (build_new_op): Add REALPART_EXPR and IMAGPART_EXPR cases.
kono
parents:
diff changeset
1909 * cvt.c (cp_convert): Handle COMPLEX_TYPE.
kono
parents:
diff changeset
1910 * error.c (dump_type_prefix, dump_type, dump_type_suffix): Add
kono
parents:
diff changeset
1911 COMPLEX_TYPE case.
kono
parents:
diff changeset
1912 * method.c (build_overload_name): Add handling of the different
kono
parents:
diff changeset
1913 COMPLEX_TYPEs, prefixing them with `J'.
kono
parents:
diff changeset
1914 * pt.c (process_template_parm): Don't let them use a COMPLEX_TYPE
kono
parents:
diff changeset
1915 as a template parm.
kono
parents:
diff changeset
1916 (uses_template_parms, tsubst, unify): Add COMPLEX_TYPE case.
kono
parents:
diff changeset
1917 * tree.c (lvalue_p): Add REALPART_EXPR and IMAGPART_EXPR cases.
kono
parents:
diff changeset
1918 (mapcar): Handle COMPLEX_CST.
kono
parents:
diff changeset
1919 * typeck.c (build_binary_op_nodefault): Handle COMPLEX_TYPE.
kono
parents:
diff changeset
1920 (common_type): Add code for complex types.
kono
parents:
diff changeset
1921 (build_unary_op): Add REALPART_EXPR and IMAGPART_EXPR cases.
kono
parents:
diff changeset
1922 (convert_for_assignment): Likewise.
kono
parents:
diff changeset
1923 (mark_addressable): Add REALPART_EXPR and IMAGPART_EXPR cases.
kono
parents:
diff changeset
1924
kono
parents:
diff changeset
1925 Mon May 19 12:26:27 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1926
kono
parents:
diff changeset
1927 * pt.c (tsubst): Don't pass the MINUS_EXPR for an array domain to
kono
parents:
diff changeset
1928 tsubst_expr, as it might try to do overload resolution.
kono
parents:
diff changeset
1929
kono
parents:
diff changeset
1930 Sat May 17 10:48:31 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1931
kono
parents:
diff changeset
1932 * pt.c (instantiate_class_template): Oops.
kono
parents:
diff changeset
1933
kono
parents:
diff changeset
1934 Fri May 16 14:23:57 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1935
kono
parents:
diff changeset
1936 * cp-tree.def: Add TAG_DEFN.
kono
parents:
diff changeset
1937 * pt.c (tsubst_enum): New fn.
kono
parents:
diff changeset
1938 (instantiate_class_template): Use it.
kono
parents:
diff changeset
1939 (tsubst_expr): Support TAG_DEFN.
kono
parents:
diff changeset
1940 (tsubst): Support local enums.
kono
parents:
diff changeset
1941 (tsubst_copy): Likewise.
kono
parents:
diff changeset
1942 * decl.c (finish_enum): Likewise.
kono
parents:
diff changeset
1943 (start_enum): If this is a local enum, switch to permanent_obstack.
kono
parents:
diff changeset
1944
kono
parents:
diff changeset
1945 Wed May 14 19:08:28 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1946
kono
parents:
diff changeset
1947 * decl.c (store_parm_decls): Set last_parm_cleanup_insn here.
kono
parents:
diff changeset
1948 (finish_function): Put the base init code for constructors just
kono
parents:
diff changeset
1949 after the parm cleanup insns.
kono
parents:
diff changeset
1950 (struct cp_function): Add last_parm_cleanup_insn.
kono
parents:
diff changeset
1951 (push_cp_function_context): Likewise.
kono
parents:
diff changeset
1952 (pop_cp_function_context): Likewise.
kono
parents:
diff changeset
1953
kono
parents:
diff changeset
1954 Tue May 13 15:51:20 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1955
kono
parents:
diff changeset
1956 * pt.c (tsubst_copy): Handle BIT_NOT_EXPR.
kono
parents:
diff changeset
1957
kono
parents:
diff changeset
1958 Wed May 7 11:17:59 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1959
kono
parents:
diff changeset
1960 * method.c (emit_thunk) [ASM_OUTPUT_MI_THUNK]: Build up the RTL
kono
parents:
diff changeset
1961 for THUNK_FNDECL before we switch to temporary allocation.
kono
parents:
diff changeset
1962
kono
parents:
diff changeset
1963 Mon May 5 14:46:53 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1964
kono
parents:
diff changeset
1965 * call.c (build_new_op): Handle null arg2 for ?:.
kono
parents:
diff changeset
1966
kono
parents:
diff changeset
1967 Thu May 1 18:26:37 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1968
kono
parents:
diff changeset
1969 * except.c (expand_exception_blocks): Ensure that we flow through
kono
parents:
diff changeset
1970 the end of the exception region for the exception specification.
kono
parents:
diff changeset
1971 Move exception region for the exception specification in, so that
kono
parents:
diff changeset
1972 it doesn't protect the parm cleanup. Remove some obsolete code.
kono
parents:
diff changeset
1973 * decl.c (store_parm_decls): Likewise.
kono
parents:
diff changeset
1974 (finish_function): Likewise.
kono
parents:
diff changeset
1975
kono
parents:
diff changeset
1976 Tue Apr 29 15:38:54 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1977
kono
parents:
diff changeset
1978 * init.c (build_new): Fix nothrow handling.
kono
parents:
diff changeset
1979
kono
parents:
diff changeset
1980 Tue Apr 29 14:29:50 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1981
kono
parents:
diff changeset
1982 * init.c (emit_base_init): Don't warn about the initialization
kono
parents:
diff changeset
1983 list for an artificial member.
kono
parents:
diff changeset
1984
kono
parents:
diff changeset
1985 Fri Apr 25 17:47:59 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1986
kono
parents:
diff changeset
1987 * expr.c (do_case): Handle !START case for the error msg.
kono
parents:
diff changeset
1988
kono
parents:
diff changeset
1989 Fri Apr 25 11:55:23 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1990
kono
parents:
diff changeset
1991 * decl2.c, lang-options.h: New option -Weffc++.
kono
parents:
diff changeset
1992 * class.c, decl.c, init.c, typeck.c: Move Effective C++ warnings
kono
parents:
diff changeset
1993 to -Weffc++.
kono
parents:
diff changeset
1994
kono
parents:
diff changeset
1995 * decl2.c (finish_prevtable_vardecl): Change NO_LINKAGE_HEURISTICS
kono
parents:
diff changeset
1996 to MULTIPLE_SYMBOL_SPACES.
kono
parents:
diff changeset
1997
kono
parents:
diff changeset
1998 Wed Apr 23 18:06:50 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1999
kono
parents:
diff changeset
2000 * method.c (emit_thunk, generic case): Set current_function_is_thunk.
kono
parents:
diff changeset
2001
kono
parents:
diff changeset
2002 * method.c (emit_thunk, macro case): Set up DECL_RESULT.
kono
parents:
diff changeset
2003
kono
parents:
diff changeset
2004 * typeck.c (c_expand_return): Don't complain about returning void
kono
parents:
diff changeset
2005 to void in an artificial function.
kono
parents:
diff changeset
2006 * method.c (make_thunk): Change settings of READONLY/VOLATILE,
kono
parents:
diff changeset
2007 don't set DECL_RESULT, set DECL_ARTIFICIAL.
kono
parents:
diff changeset
2008 (emit_thunk, generic code): Also set up DECL_LANG_SPECIFIC.
kono
parents:
diff changeset
2009
kono
parents:
diff changeset
2010 Wed Apr 23 14:43:06 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2011
kono
parents:
diff changeset
2012 * init.c (init_decl_processing): Add support for setjmp/longjmp based
kono
parents:
diff changeset
2013 exception handling.
kono
parents:
diff changeset
2014 * except.c (init_exception_processing): Likewise.
kono
parents:
diff changeset
2015 (expand_end_catch_block): Likewise.
kono
parents:
diff changeset
2016 (expand_exception_blocks): Likewise.
kono
parents:
diff changeset
2017 (expand_throw): Likewise.
kono
parents:
diff changeset
2018 * exception.cc (__default_terminate): Likewise.
kono
parents:
diff changeset
2019
kono
parents:
diff changeset
2020 * init.c (perform_member_init): Use new method of expr level
kono
parents:
diff changeset
2021 cleanups, instead of cleanups_this_call and friends.
kono
parents:
diff changeset
2022 (emit_base_init): Likewise.
kono
parents:
diff changeset
2023 (expand_aggr_vbase_init_1): Likewise.
kono
parents:
diff changeset
2024 (expand_vec_init): Likewise.
kono
parents:
diff changeset
2025 * decl.c (cp_finish_decl): Likewise.
kono
parents:
diff changeset
2026 (expand_static_init): Likewise.
kono
parents:
diff changeset
2027 (store_parm_decls): Likewise.
kono
parents:
diff changeset
2028 (cplus_expand_expr_stmt): Likewise.
kono
parents:
diff changeset
2029 * decl2.c (finish_file): Likewise.
kono
parents:
diff changeset
2030
kono
parents:
diff changeset
2031 * Make-lang.in (exception.o): Ok to compile with -O now.
kono
parents:
diff changeset
2032
kono
parents:
diff changeset
2033 * decl.c (maybe_build_cleanup_1): We no longer have to unsave, as
kono
parents:
diff changeset
2034 we know it will be done later by the backend.
kono
parents:
diff changeset
2035
kono
parents:
diff changeset
2036 * decl2.c (lang_f_options): Remove support for short temps.
kono
parents:
diff changeset
2037 * lang-options.h: Likewise.
kono
parents:
diff changeset
2038
kono
parents:
diff changeset
2039 Wed Apr 23 04:12:06 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2040
kono
parents:
diff changeset
2041 * tree.c (varargs_function_p): New fn.
kono
parents:
diff changeset
2042 * method.c (emit_thunk): Replace broken generic code with code to
kono
parents:
diff changeset
2043 generate a heavyweight thunk function.
kono
parents:
diff changeset
2044
kono
parents:
diff changeset
2045 Tue Apr 22 02:45:18 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2046
kono
parents:
diff changeset
2047 * pt.c (process_template_parm): pedwarn about floating-point parms.
kono
parents:
diff changeset
2048
kono
parents:
diff changeset
2049 * decl.c (grokdeclarator): inline no longer implies static.
kono
parents:
diff changeset
2050
kono
parents:
diff changeset
2051 * spew.c (yylex): Always return the TYPE_DECL if we got a scope.
kono
parents:
diff changeset
2052
kono
parents:
diff changeset
2053 Mon Apr 21 15:42:27 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2054
kono
parents:
diff changeset
2055 * class.c (check_for_override): The signature of an overriding
kono
parents:
diff changeset
2056 function is not changed.
kono
parents:
diff changeset
2057
kono
parents:
diff changeset
2058 * call.c (build_over_call): Move setting of conv into the loop.
kono
parents:
diff changeset
2059 Note: this change, along with the related changes of the 18th thru
kono
parents:
diff changeset
2060 the 20th of April, fix an infinite loop problem in conversions.
kono
parents:
diff changeset
2061
kono
parents:
diff changeset
2062 Sun Apr 20 16:24:29 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2063
kono
parents:
diff changeset
2064 * call.c (build_user_type_conversion_1): Really ignore rvalue
kono
parents:
diff changeset
2065 conversions when looking for a REFERENCE_TYPE.
kono
parents:
diff changeset
2066
kono
parents:
diff changeset
2067 * cvt.c (build_up_reference): Eviscerate, use build_unary_op.
kono
parents:
diff changeset
2068 * cp-tree.h (TREE_REFERENCE_EXPR): #if 0.
kono
parents:
diff changeset
2069 * typeck.c (decay_conversion): Don't set TREE_REFERENCE_EXPR.
kono
parents:
diff changeset
2070 (build_unary_op): Likewise.
kono
parents:
diff changeset
2071 * call.c (build_over_call): See through a CONVERT_EXPR around the
kono
parents:
diff changeset
2072 ADDR_EXPR for on a temporary.
kono
parents:
diff changeset
2073 * typeck.c (c_expand_return): See through a CONVERT_EXPR around
kono
parents:
diff changeset
2074 the ADDR_EXPR for a local variable.
kono
parents:
diff changeset
2075
kono
parents:
diff changeset
2076 Fri Apr 18 12:11:33 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2077
kono
parents:
diff changeset
2078 * call.c (build_user_type_conversion_1): If we're trying to
kono
parents:
diff changeset
2079 convert to a REFERENCE_TYPE, only consider lvalue conversions.
kono
parents:
diff changeset
2080 (build_new_function_call): Print candidates.
kono
parents:
diff changeset
2081 (implicit_conversion): Try a temp binding if the lvalue conv is BAD.
kono
parents:
diff changeset
2082 (reference_binding): Binding a temporary of a reference-related type
kono
parents:
diff changeset
2083 is BAD.
kono
parents:
diff changeset
2084
kono
parents:
diff changeset
2085 Thu Apr 17 14:37:22 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2086
kono
parents:
diff changeset
2087 * inc/typeinfo (type_info::before): Add cv-qualifier-seq.
kono
parents:
diff changeset
2088 * tinfo2.cc (type_info::before): Likewise.
kono
parents:
diff changeset
2089
kono
parents:
diff changeset
2090 Mon Apr 14 12:38:17 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2091
kono
parents:
diff changeset
2092 * call.c (implicit_conversion): Oops.
kono
parents:
diff changeset
2093
kono
parents:
diff changeset
2094 Fri Apr 11 02:18:30 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2095
kono
parents:
diff changeset
2096 * call.c (implicit_conversion): Try to find a reference conversion
kono
parents:
diff changeset
2097 before binding a const reference to a temporary.
kono
parents:
diff changeset
2098
kono
parents:
diff changeset
2099 Wed Apr 2 12:51:36 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2100
kono
parents:
diff changeset
2101 * exception.cc (__default_unexpected): Call terminate by default,
kono
parents:
diff changeset
2102 so that if the user overrides terminate, the correct function will
kono
parents:
diff changeset
2103 be called.
kono
parents:
diff changeset
2104
kono
parents:
diff changeset
2105 Wed Mar 19 14:14:45 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2106
kono
parents:
diff changeset
2107 * parse.y (left_curly): Avoid trying to use any fields of
kono
parents:
diff changeset
2108 error_mark_node, as there aren't any.
kono
parents:
diff changeset
2109
kono
parents:
diff changeset
2110 Thu Mar 13 16:33:22 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2111
kono
parents:
diff changeset
2112 * lex.c (do_identifier): Avoid breaking on overloaded methods
kono
parents:
diff changeset
2113 as default arguments.
kono
parents:
diff changeset
2114
kono
parents:
diff changeset
2115 Wed Mar 12 13:55:10 1997 Hans-Peter Nilsson <Hans-Peter.Nilsson@axis.se>
kono
parents:
diff changeset
2116
kono
parents:
diff changeset
2117 * call.c (add_template_candidate): Initialize the variable "dummy".
kono
parents:
diff changeset
2118
kono
parents:
diff changeset
2119 Mon Mar 10 15:13:14 1997 Brendan Kehoe <brendan@canuck.cygnus.com>
kono
parents:
diff changeset
2120
kono
parents:
diff changeset
2121 * decl.c (start_decl): Make sure TYPE isn't an error_mark_node
kono
parents:
diff changeset
2122 before we try to use TYPE_SIZE and TREE_CONSTANT on it.
kono
parents:
diff changeset
2123
kono
parents:
diff changeset
2124 Fri Mar 7 13:19:36 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2125
kono
parents:
diff changeset
2126 * cp-tree.h (comp_ptr_ttypes, more_specialized): Add decl.
kono
parents:
diff changeset
2127 (debug_binfo): Delete decl, not needed.
kono
parents:
diff changeset
2128
kono
parents:
diff changeset
2129 * tree.c (fnaddr_from_vtable_entry, function_arg_chain,
kono
parents:
diff changeset
2130 promotes_to_aggr_type): Delete fns.
kono
parents:
diff changeset
2131 * cp-tree.h (FNADDR_FROM_VTABLE_ENTRY,
kono
parents:
diff changeset
2132 SET_FNADDR_FROM_VTABLE_ENTRY, FUNCTION_ARG_CHAIN,
kono
parents:
diff changeset
2133 PROMOTES_TO_AGGR_TYPE): Delete alternates to #if 1.
kono
parents:
diff changeset
2134
kono
parents:
diff changeset
2135 * decl.c (pending_invalid_xref{,_file,_line}): Delete unused vars.
kono
parents:
diff changeset
2136
kono
parents:
diff changeset
2137 * friend.c (is_friend_type): Delete fn.
kono
parents:
diff changeset
2138 * cp-tree.h (is_friend_type): Delete decl.
kono
parents:
diff changeset
2139
kono
parents:
diff changeset
2140 * decl.c (original_result_rtx, double_ftype_double,
kono
parents:
diff changeset
2141 double_ftype_double_double, int_ftype_int, long_ftype_long,
kono
parents:
diff changeset
2142 float_ftype_float, ldouble_ftype_ldouble, last_dtor_insn): Make static.
kono
parents:
diff changeset
2143 * typeck.c (original_result_rtx, warn_synth): Delete extern decls.
kono
parents:
diff changeset
2144
kono
parents:
diff changeset
2145 * decl.c (push_overloaded_decl{,_top_level}): Make static, adding
kono
parents:
diff changeset
2146 fwd decls.
kono
parents:
diff changeset
2147 * cp-tree.h (push_overloaded_decl{,_top_level}): Delete decls.
kono
parents:
diff changeset
2148
kono
parents:
diff changeset
2149 * decl.c (pushdecl_nonclass_level): #if 0, unused.
kono
parents:
diff changeset
2150 * cp-tree.h (pushdecl_nonclass_level): #if 0 decl.
kono
parents:
diff changeset
2151
kono
parents:
diff changeset
2152 * lex.c (reinit_lang_specific): #if 0, unused.
kono
parents:
diff changeset
2153 * cp-tree.h (reinit_lang_specific): #if 0 decl.
kono
parents:
diff changeset
2154
kono
parents:
diff changeset
2155 * decl.c (revert_static_member_fn): Make static, adding fwd decl.
kono
parents:
diff changeset
2156 * cp-tree.h (revert_static_member_fn): Delete decl.
kono
parents:
diff changeset
2157
kono
parents:
diff changeset
2158 * class.c (root_lang_context_p): Delete fn.
kono
parents:
diff changeset
2159 * cp-tree.h (root_lang_context_p): Delete decl.
kono
parents:
diff changeset
2160
kono
parents:
diff changeset
2161 * decl.c (set_current_level_tags_transparency): #if 0, unused.
kono
parents:
diff changeset
2162 * cp-tree.h (set_current_level_tags_transparency): #if 0 decl.
kono
parents:
diff changeset
2163
kono
parents:
diff changeset
2164 * lex.c (set_vardecl_interface_info): Make static.
kono
parents:
diff changeset
2165 * cp-tree.h (set_vardecl_interface_info): Delete decl.
kono
parents:
diff changeset
2166
kono
parents:
diff changeset
2167 * call.c (find_scoped_type): Make static.
kono
parents:
diff changeset
2168 * cp-tree.h (find_scoped_type): Delete decl.
kono
parents:
diff changeset
2169
kono
parents:
diff changeset
2170 * search.c (convert_pointer_to_vbase): Make static.
kono
parents:
diff changeset
2171 * cp-tree.h (convert_pointer_to_vbase): Delete decl.
kono
parents:
diff changeset
2172
kono
parents:
diff changeset
2173 * decl.c (const_ptr_type_node): Likewise.
kono
parents:
diff changeset
2174 * cp-tree.h (const_ptr_type_node): Delete decl.
kono
parents:
diff changeset
2175
kono
parents:
diff changeset
2176 * typeck.c (common_base_type): Make static.
kono
parents:
diff changeset
2177 * cp-tree.h (common_base_types): Delete erroneous decl.
kono
parents:
diff changeset
2178
kono
parents:
diff changeset
2179 * pt.c (classtype_mangled_name): Make static.
kono
parents:
diff changeset
2180 * cp-tree.h (classtype_mangled_name): Delete decl.
kono
parents:
diff changeset
2181
kono
parents:
diff changeset
2182 * lex.c (check_newline): Make static.
kono
parents:
diff changeset
2183 * cp-tree.h (check_newline): Delete decl.
kono
parents:
diff changeset
2184
kono
parents:
diff changeset
2185 * typeck.c (build_x_array_ref): Delete fn, same idea as
kono
parents:
diff changeset
2186 grok_array_decl.
kono
parents:
diff changeset
2187 * cp-tree.h (build_x_array_ref): Delete decl.
kono
parents:
diff changeset
2188
kono
parents:
diff changeset
2189 * lex.c (copy_decl_lang_specific): Delete fn, same idea as
kono
parents:
diff changeset
2190 copy_lang_decl.
kono
parents:
diff changeset
2191 * cp-tree.h (copy_decl_lang_specific): #if 0 decl.
kono
parents:
diff changeset
2192
kono
parents:
diff changeset
2193 * class.c (build_vtable_entry): Make static.
kono
parents:
diff changeset
2194 * cp-tree.h (build_vtable_entry): Delete decl.
kono
parents:
diff changeset
2195
kono
parents:
diff changeset
2196 * class.c (build_vbase_pointer): Make static.
kono
parents:
diff changeset
2197 * cp-tree.h (build_vbase_pointer): Delete decl.
kono
parents:
diff changeset
2198
kono
parents:
diff changeset
2199 * sig.c (build_sptr_ref): Add forward decl and make static.
kono
parents:
diff changeset
2200 * cp-tree.h (build_sptr_ref): Delete decl.
kono
parents:
diff changeset
2201
kono
parents:
diff changeset
2202 * call.c (build_new_method_call): Add forward decl and make static.
kono
parents:
diff changeset
2203 * cp-tree.h (build_new_method_call): Delete decl.
kono
parents:
diff changeset
2204
kono
parents:
diff changeset
2205 * call.c (build_object_call): Make static.
kono
parents:
diff changeset
2206 * class.c (check_for_override, complete_type_p, mark_overriders):
kono
parents:
diff changeset
2207 Likewise.
kono
parents:
diff changeset
2208 * decl.c (cp_function_chain): Likewise.
kono
parents:
diff changeset
2209 * lex.c (set_typedecl_interface_info, reinit_parse_for_block):
kono
parents:
diff changeset
2210 Likewise.
kono
parents:
diff changeset
2211 * pt.c (comp_template_args, get_class_bindings, push_tinst_level):
kono
parents:
diff changeset
2212 Likewise.
kono
parents:
diff changeset
2213 * tree.c (build_cplus_array_type_1): Likewise.
kono
parents:
diff changeset
2214 * typeck.c (comp_ptr_ttypes_{const,real,reinterpret}): Likewise.
kono
parents:
diff changeset
2215 (comp_target_parms): Likewise.
kono
parents:
diff changeset
2216
kono
parents:
diff changeset
2217 * init.c (build_builtin_call): Make static.
kono
parents:
diff changeset
2218 * cp-tree.h (build_builtin_call): Delete decl.
kono
parents:
diff changeset
2219
kono
parents:
diff changeset
2220 * typeck.c (binary_op_error): Delete decl.
kono
parents:
diff changeset
2221 * cp-tree.h (binary_op_error): Likewise.
kono
parents:
diff changeset
2222
kono
parents:
diff changeset
2223 Thu Mar 6 16:13:52 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2224
kono
parents:
diff changeset
2225 * call.c (build_method_call): Compare against error_mark_node
kono
parents:
diff changeset
2226 directly, rather than the ERROR_MARK tree code.
kono
parents:
diff changeset
2227 * cvt.c (cp_convert): Likewise.
kono
parents:
diff changeset
2228 * decl.c (print_binding_level): Likewise.
kono
parents:
diff changeset
2229 (duplicate_decls): Likewise.
kono
parents:
diff changeset
2230 (grokdeclarator): Likewise.
kono
parents:
diff changeset
2231 (grokdeclarator): Likewise.
kono
parents:
diff changeset
2232 * init.c (expand_aggr_init_1): Likewise.
kono
parents:
diff changeset
2233 (decl_constant_value): Likewise.
kono
parents:
diff changeset
2234 * method.c (build_opfncall): Likewise.
kono
parents:
diff changeset
2235 (hack_identifier): Likewise.
kono
parents:
diff changeset
2236 * typeck.c (build_modify_expr): Likewise.
kono
parents:
diff changeset
2237
kono
parents:
diff changeset
2238 * typeck.c (build_c_cast): Don't decl TYPE as register tree.
kono
parents:
diff changeset
2239
kono
parents:
diff changeset
2240 Sun Mar 2 02:54:36 1997 Bruno Haible <bruno@linuix.mathematik.uni-karlsruhe.de>
kono
parents:
diff changeset
2241
kono
parents:
diff changeset
2242 * pt.c (unify): Strip NOP_EXPR wrappers before unifying integer values.
kono
parents:
diff changeset
2243
kono
parents:
diff changeset
2244 * pt.c (coerce_template_parms): Add new error message.
kono
parents:
diff changeset
2245
kono
parents:
diff changeset
2246 * method.c (build_overload_value): Implement name mangling for
kono
parents:
diff changeset
2247 floating-point template arguments.
kono
parents:
diff changeset
2248
kono
parents:
diff changeset
2249 * method.c (build_overload_int, icat, dicat): Fix mangling of template
kono
parents:
diff changeset
2250 arguments whose absolute value doesn't fit in a signed word.
kono
parents:
diff changeset
2251
kono
parents:
diff changeset
2252 Mon Mar 3 12:14:54 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2253
kono
parents:
diff changeset
2254 * friend.c: New file; put all of the friend stuff in here.
kono
parents:
diff changeset
2255 * init.c: Instead of here.
kono
parents:
diff changeset
2256 * Makefile.in (CXX_OBJS): Add friend.o.
kono
parents:
diff changeset
2257 (friend.o): Add dependencies.
kono
parents:
diff changeset
2258 * Make-lang.in (CXX_SRCS): Add $(srcdir)/cp/friend.c.
kono
parents:
diff changeset
2259
kono
parents:
diff changeset
2260 Sun Mar 2 11:04:43 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2261
kono
parents:
diff changeset
2262 * call.c (build_scoped_method_call): Complain if the scope isn't a
kono
parents:
diff changeset
2263 base.
kono
parents:
diff changeset
2264
kono
parents:
diff changeset
2265 Wed Feb 26 11:31:06 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2266
kono
parents:
diff changeset
2267 * parse.y (left_curly): Don't crash on erroneous type.
kono
parents:
diff changeset
2268
kono
parents:
diff changeset
2269 * init.c (build_delete): Fix type of ref.
kono
parents:
diff changeset
2270
kono
parents:
diff changeset
2271 Tue Feb 25 12:41:48 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2272
kono
parents:
diff changeset
2273 * search.c (get_vbase_1): Renamed from get_vbase.
kono
parents:
diff changeset
2274 (get_vbase): Wrapper, now non-static.
kono
parents:
diff changeset
2275 (convert_pointer_to_vbase): Now static.
kono
parents:
diff changeset
2276
kono
parents:
diff changeset
2277 * call.c (build_scoped_method_call): Accept a binfo for BASETYPE.
kono
parents:
diff changeset
2278 * init.c (build_delete): Pass one.
kono
parents:
diff changeset
2279 (build_partial_cleanup_for): Use build_scoped_method_call.
kono
parents:
diff changeset
2280 * decl.c (finish_function): Pass a binfo.
kono
parents:
diff changeset
2281
kono
parents:
diff changeset
2282 Mon Feb 24 15:00:12 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2283
kono
parents:
diff changeset
2284 * call.c (build_over_call): Only synthesize non-trivial copy ctors.
kono
parents:
diff changeset
2285
kono
parents:
diff changeset
2286 * typeck.c (build_c_cast): Lose other reference to flag.
kono
parents:
diff changeset
2287
kono
parents:
diff changeset
2288 * call.c (build_field_call): Don't look for [cd]tor_identifier.
kono
parents:
diff changeset
2289 * decl2.c (delete_sanity): Remove meaningless use of
kono
parents:
diff changeset
2290 LOOKUP_HAS_IN_CHARGE.
kono
parents:
diff changeset
2291 * decl.c (finish_function): Use build_scoped_method_call instead
kono
parents:
diff changeset
2292 of build_delete for running vbase dtors.
kono
parents:
diff changeset
2293 * init.c (build_delete): Call overload resolution code instead of
kono
parents:
diff changeset
2294 duplicating it badly.
kono
parents:
diff changeset
2295
kono
parents:
diff changeset
2296 Thu Feb 20 15:12:15 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2297
kono
parents:
diff changeset
2298 * call.c (build_over_call): Call mark_used before trying to elide
kono
parents:
diff changeset
2299 the call.
kono
parents:
diff changeset
2300
kono
parents:
diff changeset
2301 * decl.c (implicitly_declare): Don't set DECL_ARTIFICIAL.
kono
parents:
diff changeset
2302
kono
parents:
diff changeset
2303 Wed Feb 19 11:18:53 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2304
kono
parents:
diff changeset
2305 * typeck.c (build_modify_expr): Always pedwarn for a cast to
kono
parents:
diff changeset
2306 non-reference used as an lvalue.
kono
parents:
diff changeset
2307
kono
parents:
diff changeset
2308 Wed Feb 19 10:35:37 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2309
kono
parents:
diff changeset
2310 * cvt.c (cp_convert_to_pointer): Convert from 0 to a pmf properly.
kono
parents:
diff changeset
2311
kono
parents:
diff changeset
2312 Tue Feb 18 15:40:57 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2313
kono
parents:
diff changeset
2314 * parse.y (handler): Fix template typo.
kono
parents:
diff changeset
2315
kono
parents:
diff changeset
2316 Sun Feb 16 02:12:28 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2317
kono
parents:
diff changeset
2318 * error.c (lang_decl_name): New fn.
kono
parents:
diff changeset
2319 * tree.c (lang_printable_name): Use it.
kono
parents:
diff changeset
2320
kono
parents:
diff changeset
2321 Fri Feb 14 16:57:05 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2322
kono
parents:
diff changeset
2323 * g++spec.c: Include config.h so that we can catch bzero #defines
kono
parents:
diff changeset
2324 from the config file.
kono
parents:
diff changeset
2325
kono
parents:
diff changeset
2326 Tue Feb 11 13:50:48 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2327
kono
parents:
diff changeset
2328 * new1.cc: Include a declaration for malloc, to avoid warning, and
kono
parents:
diff changeset
2329 avoid lossing on systems that require one (ones that define malloc
kono
parents:
diff changeset
2330 in xm.h).
kono
parents:
diff changeset
2331
kono
parents:
diff changeset
2332 Mon Feb 10 22:51:13 1997 Bruno Haible <bruno@linuix.mathematik.uni-karlsruhe.de>
kono
parents:
diff changeset
2333
kono
parents:
diff changeset
2334 * decl2.c (max_tinst_depth): New variable.
kono
parents:
diff changeset
2335 (lang_decode_option): Parse "-ftemplate-depth-NN" command line
kono
parents:
diff changeset
2336 option.
kono
parents:
diff changeset
2337 * pt.c (max_tinst_depth): Variable moved.
kono
parents:
diff changeset
2338 * lang-options.h: Declare "-ftemplate-depth-NN" command line option
kono
parents:
diff changeset
2339 as legal.
kono
parents:
diff changeset
2340
kono
parents:
diff changeset
2341 Fri Feb 7 15:43:34 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2342
kono
parents:
diff changeset
2343 * decl.c (xref_basetypes): Allow a base class that depends on
kono
parents:
diff changeset
2344 template parms to be incomplete.
kono
parents:
diff changeset
2345
kono
parents:
diff changeset
2346 * decl2.c (build_expr_from_tree): Support typeid(type).
kono
parents:
diff changeset
2347 * rtti.c (get_typeid): Support templates.
kono
parents:
diff changeset
2348 (expand_si_desc, expand_class_desc): Fix string length.
kono
parents:
diff changeset
2349 (expand_ptr_desc, expand_attr_desc, expand_generic_desc): Likewise.
kono
parents:
diff changeset
2350
kono
parents:
diff changeset
2351 Tue Feb 4 11:28:24 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2352
kono
parents:
diff changeset
2353 * pt.c (unify, case TEMPLATE_CONST_PARM): Use cp_tree_equal.
kono
parents:
diff changeset
2354
kono
parents:
diff changeset
2355 * pt.c (tsubst): Put it back for -fno-ansi-overloading.
kono
parents:
diff changeset
2356
kono
parents:
diff changeset
2357 Mon Feb 3 18:41:12 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2358
kono
parents:
diff changeset
2359 * pt.c (tsubst, case FUNCTION_DECL): Lose obsolete code that
kono
parents:
diff changeset
2360 smashes together template and non-template decls of the same
kono
parents:
diff changeset
2361 signature.
kono
parents:
diff changeset
2362
kono
parents:
diff changeset
2363 Thu Jan 30 19:18:00 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2364
kono
parents:
diff changeset
2365 * pt.c (tsubst): Don't recurse for the type of a TYPENAME_TYPE.
kono
parents:
diff changeset
2366
kono
parents:
diff changeset
2367 Wed Jan 29 11:40:35 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2368
kono
parents:
diff changeset
2369 * decl.c (duplicate_decls): Next route, pedwarn about different
kono
parents:
diff changeset
2370 exceptions if -pedantic *or* olddecl !DECL_IN_SYSTEM_HEADER.
kono
parents:
diff changeset
2371
kono
parents:
diff changeset
2372 Tue Jan 28 20:43:29 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2373
kono
parents:
diff changeset
2374 * cp-tree.h (HAS_DEFAULT_IMPLEMENTATION): Delete macro.
kono
parents:
diff changeset
2375 (struct lang_type): Delete has_default_implementation member.
kono
parents:
diff changeset
2376 Increase dummy to 21.
kono
parents:
diff changeset
2377 * decl.c (start_method): Delete usage.
kono
parents:
diff changeset
2378
kono
parents:
diff changeset
2379 * cp-tree.h (build_call, null_ptr_cst_p, in_function_p,
kono
parents:
diff changeset
2380 store_after_parms, start_decl_1, auto_function): Add decls.
kono
parents:
diff changeset
2381 (get_arglist_len_in_bytes, declare_implicit_exception,
kono
parents:
diff changeset
2382 have_exceptions_p, make_type_decl, typedecl_for_tag,
kono
parents:
diff changeset
2383 store_in_parms, pop_implicit_try_blocks, push_exception_cleanup,
kono
parents:
diff changeset
2384 build_component_type_expr, cplus_exception_name,
kono
parents:
diff changeset
2385 {make,clear}_anon_parm_name, dont_see_typename): Removed decls.
kono
parents:
diff changeset
2386 * call.c (build_this): Make static.
kono
parents:
diff changeset
2387 (is_complete): Likewise.
kono
parents:
diff changeset
2388 (implicit_conversion): Likewise.
kono
parents:
diff changeset
2389 (reference_binding): Likewise.
kono
parents:
diff changeset
2390 (standard_conversion): Likewise.
kono
parents:
diff changeset
2391 (strip_top_quals): Likewise.
kono
parents:
diff changeset
2392 (non_reference): Likewise.
kono
parents:
diff changeset
2393 (build_conv): Likewise.
kono
parents:
diff changeset
2394 (user_harshness): Likewise.
kono
parents:
diff changeset
2395 (rank_for_ideal): Likewise.
kono
parents:
diff changeset
2396 * decl.c (start_decl_1): Delete forward decl.
kono
parents:
diff changeset
2397 (push_decl_level): Make static.
kono
parents:
diff changeset
2398 (resume_binding_level): Make static.
kono
parents:
diff changeset
2399 (namespace_bindings_p): Make static.
kono
parents:
diff changeset
2400 (declare_namespace_level): Make static.
kono
parents:
diff changeset
2401 (lookup_name_real): Make static.
kono
parents:
diff changeset
2402 (duplicate_decls): Make static. Take register off NEWDECL and
kono
parents:
diff changeset
2403 OLDDECL parm decls.
kono
parents:
diff changeset
2404 * decl2.c (get_sentry): Make static.
kono
parents:
diff changeset
2405 (temp_name_p): Delete fn.
kono
parents:
diff changeset
2406 * except.c (auto_function): Delete decl.
kono
parents:
diff changeset
2407 * lex.c (handle_{cp,sysv}_pragma): Make static.
kono
parents:
diff changeset
2408 (handle_sysv_pragma) [HANDLE_SYSV_PRAGMA]: Add forward decl.
kono
parents:
diff changeset
2409 * method.c (do_build_{copy_constructor,assign_ref}): Make static.
kono
parents:
diff changeset
2410 * pt.c (tsubst_expr_values): Make static.
kono
parents:
diff changeset
2411 * rtti.c (combine_strings): Delete decl.
kono
parents:
diff changeset
2412
kono
parents:
diff changeset
2413 Tue Jan 28 16:40:40 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2414
kono
parents:
diff changeset
2415 * pt.c (push_template_decl): Handle getting a typedef.
kono
parents:
diff changeset
2416
kono
parents:
diff changeset
2417 * call.c (build_new_function_call): Complain about void arg.
kono
parents:
diff changeset
2418
kono
parents:
diff changeset
2419 Tue Jan 28 15:25:09 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2420
kono
parents:
diff changeset
2421 * decl.c (duplicate_decls): Give pedwarn of different exceptions
kono
parents:
diff changeset
2422 if -pedantic, instead of olddecl !DECL_IN_SYSTEM_HEADER.
kono
parents:
diff changeset
2423
kono
parents:
diff changeset
2424 Mon Jan 27 19:21:29 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2425
kono
parents:
diff changeset
2426 * except.c (expand_throw): Don't expand the cleanup tree here,
kono
parents:
diff changeset
2427 since we are not going to write the rtl out. Fixes problem with
kono
parents:
diff changeset
2428 -g -O on SPARC.
kono
parents:
diff changeset
2429
kono
parents:
diff changeset
2430 Mon Jan 27 16:24:35 1997 Sean McNeil <sean@mcneil.com>
kono
parents:
diff changeset
2431
kono
parents:
diff changeset
2432 * Make-lang.in: Add $(exeext) as necessary.
kono
parents:
diff changeset
2433
kono
parents:
diff changeset
2434 Mon Jan 27 13:20:39 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2435
kono
parents:
diff changeset
2436 * parse.y (handler_seq): Must have at least one catch clause.
kono
parents:
diff changeset
2437
kono
parents:
diff changeset
2438 Sat Jan 25 12:00:05 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2439
kono
parents:
diff changeset
2440 * call.c (add_builtin_candidate): Restore ?: hack.
kono
parents:
diff changeset
2441
kono
parents:
diff changeset
2442 * decl.c (grok_op_properties): More warnings.
kono
parents:
diff changeset
2443
kono
parents:
diff changeset
2444 Sat Jan 25 08:50:03 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2445
kono
parents:
diff changeset
2446 * decl.c (duplicate_decls): On second thought, do it as a pedwarn
kono
parents:
diff changeset
2447 still but only if !DECL_IN_SYSTEM_HEADER (olddecl).
kono
parents:
diff changeset
2448
kono
parents:
diff changeset
2449 * decl.c (duplicate_decls): Scale back to a warning, and only do
kono
parents:
diff changeset
2450 'em if -pedantic.
kono
parents:
diff changeset
2451
kono
parents:
diff changeset
2452 Fri Jan 24 17:52:54 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2453
kono
parents:
diff changeset
2454 * decl.c (duplicate_decls): pedwarn mismatched exception
kono
parents:
diff changeset
2455 specifications.
kono
parents:
diff changeset
2456
kono
parents:
diff changeset
2457 Thu Jan 23 18:18:54 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2458
kono
parents:
diff changeset
2459 * call.c (build_new_method_call): Don't display the invisible
kono
parents:
diff changeset
2460 argument for controlling virtual bases.
kono
parents:
diff changeset
2461
kono
parents:
diff changeset
2462 Thu Jan 23 16:48:10 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2463
kono
parents:
diff changeset
2464 * new: Add nothrow new and delete, bad_alloc and throw specifications
kono
parents:
diff changeset
2465 for delete.
kono
parents:
diff changeset
2466 * decl.c (init_decl_processing): Add throw specification for delete.
kono
parents:
diff changeset
2467 * new.cc (nothrow): Define.
kono
parents:
diff changeset
2468 * lex.c (real_yylex): Removing warning that throw and friends are
kono
parents:
diff changeset
2469 keywords.
kono
parents:
diff changeset
2470 * new1.cc (operator new (size_t sz, const nothrow_t&)): Define.
kono
parents:
diff changeset
2471 * new2.cc (operator new[] (size_t sz, const nothrow_t&): Define.
kono
parents:
diff changeset
2472 * Make-lang.in: Add new{1,2}.{cc,o}.
kono
parents:
diff changeset
2473
kono
parents:
diff changeset
2474 Thu Jan 23 16:39:06 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2475
kono
parents:
diff changeset
2476 * lex.c (cons_up_default_function): Fix return type of synth op=.
kono
parents:
diff changeset
2477
kono
parents:
diff changeset
2478 * init.c (emit_base_init): Add warnings for uninitialized members
kono
parents:
diff changeset
2479 and bases.
kono
parents:
diff changeset
2480
kono
parents:
diff changeset
2481 * decl.c (xref_basetypes): Add warning for non-polymorphic type
kono
parents:
diff changeset
2482 with destructor used as base type.
kono
parents:
diff changeset
2483
kono
parents:
diff changeset
2484 * decl.c (grok_op_properties): Add warning for op= returning void.
kono
parents:
diff changeset
2485 * typeck.c (c_expand_return): Add warning for op= returning anything
kono
parents:
diff changeset
2486 other than *this.
kono
parents:
diff changeset
2487
kono
parents:
diff changeset
2488 * class.c (finish_struct_1): Add warning for class with pointers
kono
parents:
diff changeset
2489 but not copy ctor or copy op=.
kono
parents:
diff changeset
2490
kono
parents:
diff changeset
2491 * cp-tree.h (TI_PENDING_TEMPLATE_FLAG): New macro.
kono
parents:
diff changeset
2492 * pt.c (add_pending_template): Use it instead of LANG_FLAG_0.
kono
parents:
diff changeset
2493 (instantiate_template): If -fexternal-templates, add this
kono
parents:
diff changeset
2494 instantiation to pending_templates.
kono
parents:
diff changeset
2495
kono
parents:
diff changeset
2496 * decl2.c (copy_assignment_arg_p): Disable old hack to support
kono
parents:
diff changeset
2497 Booch components.
kono
parents:
diff changeset
2498
kono
parents:
diff changeset
2499 Tue Jan 21 18:32:04 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2500
kono
parents:
diff changeset
2501 * cvt.c (cp_convert): pedwarn enum to pointer conversions.
kono
parents:
diff changeset
2502
kono
parents:
diff changeset
2503 Mon Jan 20 17:59:51 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2504
kono
parents:
diff changeset
2505 * call.c (standard_conversion): Handle getting references. Tack
kono
parents:
diff changeset
2506 on RVALUE_CONV here. Do it for non-class types, too.
kono
parents:
diff changeset
2507 (reference_binding): Pass references to standard_conversion.
kono
parents:
diff changeset
2508 (implicit_conversion): Likewise.
kono
parents:
diff changeset
2509 (add_builtin_candidate): Disable one ?: kludge.
kono
parents:
diff changeset
2510 (convert_like): Handle RVALUE_CONVs for non-class types.
kono
parents:
diff changeset
2511 (joust): Disable the other ?: kludge.
kono
parents:
diff changeset
2512
kono
parents:
diff changeset
2513 Mon Jan 20 14:53:13 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2514
kono
parents:
diff changeset
2515 * decl.c (init_decl_processing): Add code to build up common
kono
parents:
diff changeset
2516 function types beforehand, to avoid creation then removal of
kono
parents:
diff changeset
2517 things already in the hash table.
kono
parents:
diff changeset
2518
kono
parents:
diff changeset
2519 Mon Jan 20 14:43:49 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2520
kono
parents:
diff changeset
2521 * decl.c (finish_function): Also zero out DECL_INCOMING_RTL for
kono
parents:
diff changeset
2522 the arguments.
kono
parents:
diff changeset
2523
kono
parents:
diff changeset
2524 * error.c (dump_expr, TEMPLATE_CONST_PARM): Don't require
kono
parents:
diff changeset
2525 current_template_parms.
kono
parents:
diff changeset
2526
kono
parents:
diff changeset
2527 Fri Jan 17 10:25:42 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2528
kono
parents:
diff changeset
2529 * search.c (lookup_field): Don't return a function, check want_type.
kono
parents:
diff changeset
2530
kono
parents:
diff changeset
2531 Thu Jan 16 18:14:35 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2532
kono
parents:
diff changeset
2533 * init.c (build_new): Make sure PLACEMENT has a type.
kono
parents:
diff changeset
2534
kono
parents:
diff changeset
2535 Thu Jan 16 17:40:28 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2536
kono
parents:
diff changeset
2537 * init.c (build_new): Support new (nothrow).
kono
parents:
diff changeset
2538
kono
parents:
diff changeset
2539 Wed Jan 15 12:38:14 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2540
kono
parents:
diff changeset
2541 * pt.c (instantiate_decl): Also do push_to_top_level before setting
kono
parents:
diff changeset
2542 up DECL_INITIAL.
kono
parents:
diff changeset
2543
kono
parents:
diff changeset
2544 * cp-tree.h (PARM_DEFAULT_FROM_TEMPLATE): New macro.
kono
parents:
diff changeset
2545 * pt.c (tsubst): Defer instantiation of default args.
kono
parents:
diff changeset
2546 * call.c (build_over_call): Until here.
kono
parents:
diff changeset
2547
kono
parents:
diff changeset
2548 Wed Jan 15 10:08:10 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2549
kono
parents:
diff changeset
2550 * search.c (lookup_field): Make sure we have an
kono
parents:
diff changeset
2551 IDENTIFIER_CLASS_VALUE before we try to return it.
kono
parents:
diff changeset
2552
kono
parents:
diff changeset
2553 Thu Jan 9 07:19:01 1997 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2554
kono
parents:
diff changeset
2555 * call.c (build_method_call): Delete unused var PARM.
kono
parents:
diff changeset
2556 (build_overload_call_real): Likewise.
kono
parents:
diff changeset
2557 (build_object_call): Delete unused var P.
kono
parents:
diff changeset
2558 (build_new_op): Likewise.
kono
parents:
diff changeset
2559 * decl.c (builtin_type_tdescs_{arr, len, max}): #if 0 out static
kono
parents:
diff changeset
2560 var definitions, which are never used.
kono
parents:
diff changeset
2561 (shadow_tag): Delete unused var FN.
kono
parents:
diff changeset
2562 * expr.c (cplus_expand_expr): Delete unused var ORIGINAL_TARGET.
kono
parents:
diff changeset
2563 * init.c (build_new): Delete unused var ALLOC_TEMP.
kono
parents:
diff changeset
2564 * method.c (hack_identifier): Delete unused var CONTEXT.
kono
parents:
diff changeset
2565 (do_build_copy_constructor): Delete unused var NAME.
kono
parents:
diff changeset
2566 (synthesize_method): Delete unused var BASE.
kono
parents:
diff changeset
2567 * pt.c (lookup_template_class): Delete unused var CODE_TYPE_NODE.
kono
parents:
diff changeset
2568 * rtti.c (build_headof): Delete unused var VPTR.
kono
parents:
diff changeset
2569 (get_typeid): Delete unused var T.
kono
parents:
diff changeset
2570 * typeck.c (build_conditional_expr): Delete unused vars ORIG_OP1
kono
parents:
diff changeset
2571 and ORIG_OP2.
kono
parents:
diff changeset
2572 (build_ptrmemfunc): Delete unused vars U and NINDEX.
kono
parents:
diff changeset
2573 * typeck2.c (build_functional_cast): Delete unused var BINFO.
kono
parents:
diff changeset
2574
kono
parents:
diff changeset
2575 Wed Jan 8 13:09:54 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2576
kono
parents:
diff changeset
2577 * search.c (lookup_field): Use IDENTIFIER_CLASS_VALUE to look up
kono
parents:
diff changeset
2578 things in a type being defined.
kono
parents:
diff changeset
2579 * decl.c (finish_enum): Reverse the values so that they are in
kono
parents:
diff changeset
2580 the correct order.
kono
parents:
diff changeset
2581
kono
parents:
diff changeset
2582 * pt.c (instantiate_class_template): Don't initialize
kono
parents:
diff changeset
2583 BINFO_BASETYPES until the vector is filled out.
kono
parents:
diff changeset
2584 (unify): Don't abort on conflicting bindings, just fail.
kono
parents:
diff changeset
2585 (instantiate_decl): Do push_tinst_level before any tsubsting.
kono
parents:
diff changeset
2586
kono
parents:
diff changeset
2587 * method.c (build_overload_value): Handle getting a
kono
parents:
diff changeset
2588 TEMPLATE_CONST_PARM for a pointer.
kono
parents:
diff changeset
2589
kono
parents:
diff changeset
2590 Tue Jan 7 14:00:58 1997 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2591
kono
parents:
diff changeset
2592 * init.c (expand_member_init): Don't give 'not a base' error for
kono
parents:
diff changeset
2593 templates.
kono
parents:
diff changeset
2594
kono
parents:
diff changeset
2595 * pt.c (instantiate_decl): Call import_export_decl later.
kono
parents:
diff changeset
2596
kono
parents:
diff changeset
2597 * pt.c (instantiate_class_template): Return a value.
kono
parents:
diff changeset
2598
kono
parents:
diff changeset
2599 * parse.y (extension): New rule for __extension__.
kono
parents:
diff changeset
2600 (extdef, unary_expr, decl, component_decl): Use it.
kono
parents:
diff changeset
2601
kono
parents:
diff changeset
2602 Tue Jan 7 09:20:28 1997 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2603
kono
parents:
diff changeset
2604 * class.c (base_binfo): Remove unused base_has_virtual member.
kono
parents:
diff changeset
2605 (finish_base_struct): Likewise.
kono
parents:
diff changeset
2606 (finish_struct_1): Likewise.
kono
parents:
diff changeset
2607
kono
parents:
diff changeset
2608
kono
parents:
diff changeset
2609
kono
parents:
diff changeset
2610 Copyright (C) 1997 Free Software Foundation, Inc.
kono
parents:
diff changeset
2611
kono
parents:
diff changeset
2612 Copying and distribution of this file, with or without modification,
kono
parents:
diff changeset
2613 are permitted in any medium without royalty provided the copyright
kono
parents:
diff changeset
2614 notice and this notice are preserved.