annotate gcc/cp/ChangeLog-1996 @ 120:f93fa5091070

fix conv1.c
author mir3636
date Thu, 08 Mar 2018 14:53:42 +0900
parents 04ced10e8804
children
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
111
kono
parents:
diff changeset
1 Tue Dec 31 20:25:50 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2
kono
parents:
diff changeset
3 * search.c (expand_upcast_fixups): Fix bogus code generation
kono
parents:
diff changeset
4 problem where the generated code uses the wrong index into the
kono
parents:
diff changeset
5 runtime built vtable on the stack. Old code could clobber random
kono
parents:
diff changeset
6 stack values.
kono
parents:
diff changeset
7
kono
parents:
diff changeset
8 Tue Dec 31 15:16:56 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
9
kono
parents:
diff changeset
10 * init.c (perform_member_init): Make sure the partial EH cleanups
kono
parents:
diff changeset
11 live on the function_obstack.
kono
parents:
diff changeset
12
kono
parents:
diff changeset
13 Fri Dec 27 10:31:40 1996 Paul Eggert <eggert@twinsun.com>
kono
parents:
diff changeset
14
kono
parents:
diff changeset
15 * Make-lang.in (g++spec.o): Don't use $< with an explicit target;
kono
parents:
diff changeset
16 this isn't portable to some versions of `make' (e.g. Solaris 2.5.1).
kono
parents:
diff changeset
17
kono
parents:
diff changeset
18 Tue Dec 24 10:24:03 1996 Jeffrey A Law <law@cygnus.com>
kono
parents:
diff changeset
19
kono
parents:
diff changeset
20 * decl.c (grokvardecl): Avoid ANSI style initialization.
kono
parents:
diff changeset
21
kono
parents:
diff changeset
22 Sun Dec 22 04:22:06 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
23
kono
parents:
diff changeset
24 * pt.c (tsubst): Tweak arg types for a FUNCTION_TYPE.
kono
parents:
diff changeset
25
kono
parents:
diff changeset
26 Fri Dec 20 17:09:25 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
27
kono
parents:
diff changeset
28 * pt.c (instantiate_class_template): Call grok_{ctor,op}_properties.
kono
parents:
diff changeset
29
kono
parents:
diff changeset
30 Fri Dec 20 12:17:12 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
31
kono
parents:
diff changeset
32 * g++spec.c (lang_specific_driver): Put missing hyphen in front of
kono
parents:
diff changeset
33 arguments we compare against. Start the count of I at 1, not 0,
kono
parents:
diff changeset
34 since argv[0] is still the command.
kono
parents:
diff changeset
35
kono
parents:
diff changeset
36 Thu Dec 19 11:53:57 1996 Stan Shebs <shebs@andros.cygnus.com>
kono
parents:
diff changeset
37
kono
parents:
diff changeset
38 * lang-specs.h: Accept .cp as an C++ extension.
kono
parents:
diff changeset
39
kono
parents:
diff changeset
40 Mon Dec 16 22:43:31 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
41
kono
parents:
diff changeset
42 * cp-tree.h (ptr_reasonably_similar): Add decl.
kono
parents:
diff changeset
43
kono
parents:
diff changeset
44 Thu Dec 12 15:00:35 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
45
kono
parents:
diff changeset
46 * decl.c (grokvardecl): Change SPECBITS parm to be the SPECBITS_IN
kono
parents:
diff changeset
47 pointer. New local SPECBITS with the parm's value.
kono
parents:
diff changeset
48 (grokdeclarator): Pass &specbits down.
kono
parents:
diff changeset
49
kono
parents:
diff changeset
50 * parse.y (expr_no_commas): Make sure $$ is not an error_mark_node
kono
parents:
diff changeset
51 before we try to do C_SET_EXP_ORIGINAL_CODE on it.
kono
parents:
diff changeset
52
kono
parents:
diff changeset
53 * search.c (envelope_add_decl): Check that the CLASSTYPE_CID of
kono
parents:
diff changeset
54 CONTEXT is not 0 before we try to use TYPE_DERIVES_FROM.
kono
parents:
diff changeset
55
kono
parents:
diff changeset
56 * decl.c (cplus_expand_expr_stmt): Only expand the expr if EXP is
kono
parents:
diff changeset
57 not an error_mark_node.
kono
parents:
diff changeset
58
kono
parents:
diff changeset
59 Sat Dec 7 17:20:22 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
60
kono
parents:
diff changeset
61 * cp-tree.h (TYPE_MAIN_DECL): Use TYPE_STUB_DECL.
kono
parents:
diff changeset
62 * *.c: Use TYPE_MAIN_DECL instead of TYPE_NAME where appropriate.
kono
parents:
diff changeset
63
kono
parents:
diff changeset
64 Fri Dec 6 14:40:09 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
65
kono
parents:
diff changeset
66 * decl.c (grokdeclarator): When giving an anonymous struct a name,
kono
parents:
diff changeset
67 replace TYPE_NAME instead of TYPE_IDENTIFIER (so TYPE_STUB_DECL is
kono
parents:
diff changeset
68 not affected).
kono
parents:
diff changeset
69
kono
parents:
diff changeset
70 * typeck2.c (build_m_component_ref): If component is a pointer
kono
parents:
diff changeset
71 to data member, resolve the OFFSET_REF now.
kono
parents:
diff changeset
72
kono
parents:
diff changeset
73 * call.c (convert_like): Don't go into infinite recursion.
kono
parents:
diff changeset
74
kono
parents:
diff changeset
75 * pt.c (coerce_template_parms): Use tsubst_expr for non-type args.
kono
parents:
diff changeset
76
kono
parents:
diff changeset
77 * class.c (finish_struct_1): Set DECL_ARTIFICIAL on the vptr.
kono
parents:
diff changeset
78 * tree.c (layout_basetypes): And on the vbase ptr.
kono
parents:
diff changeset
79
kono
parents:
diff changeset
80 Thu Dec 5 02:11:28 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
81
kono
parents:
diff changeset
82 * decl.c (BOOL_TYPE_SIZE): Define in terms of POINTER_SIZE or
kono
parents:
diff changeset
83 CHAR_TYPE_SIZE so bool is always the same size as another type.
kono
parents:
diff changeset
84
kono
parents:
diff changeset
85 * decl.c (pushtag): Set DECL_IGNORED_P for DWARF, too.
kono
parents:
diff changeset
86
kono
parents:
diff changeset
87 Tue Dec 3 23:18:37 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
88
kono
parents:
diff changeset
89 * decl2.c (grok_x_components): Remove synthesized methods from
kono
parents:
diff changeset
90 TYPE_METHODS of an anonymous union, complain about member
kono
parents:
diff changeset
91 functions.
kono
parents:
diff changeset
92 * decl.c (shadow_tag): Wipe out memory of synthesized methods in
kono
parents:
diff changeset
93 anonymous unions.
kono
parents:
diff changeset
94 (finish_function): Just clear the DECL_RTL of our arguments.
kono
parents:
diff changeset
95
kono
parents:
diff changeset
96 Fri Nov 29 21:54:17 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
97
kono
parents:
diff changeset
98 * decl2.c (finish_file): Emit DWARF debugging info for static data
kono
parents:
diff changeset
99 members.
kono
parents:
diff changeset
100
kono
parents:
diff changeset
101 * pt.c (tsubst): If t is a stub decl, return the stub decl for type.
kono
parents:
diff changeset
102
kono
parents:
diff changeset
103 Wed Nov 27 14:47:15 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
104
kono
parents:
diff changeset
105 * typeck.c (build_component_ref): Don't die if COMPONENT isn't a
kono
parents:
diff changeset
106 IDENTIFIER_NODE.
kono
parents:
diff changeset
107
kono
parents:
diff changeset
108 Wed Nov 27 16:05:19 1996 Michael Meissner <meissner@tiktok.cygnus.com>
kono
parents:
diff changeset
109
kono
parents:
diff changeset
110 * Make-lang.in (g++-cross$(exeext)): Fix typo.
kono
parents:
diff changeset
111
kono
parents:
diff changeset
112 Wed Nov 27 08:14:00 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
113
kono
parents:
diff changeset
114 Make the g++ driver now be a standalone program, rather than one
kono
parents:
diff changeset
115 that tries to run the gcc driver after munging up the options.
kono
parents:
diff changeset
116 * Make-lang.in (g++.c, g++spec.o): New rules.
kono
parents:
diff changeset
117 (g++.o): New rule, based on gcc.o with -DLANG_SPECIFIC_DRIVER
kono
parents:
diff changeset
118 added.
kono
parents:
diff changeset
119 (g++$(exeext)): New rule, based on xgcc rule.
kono
parents:
diff changeset
120 (g++-cross$(exeext)): Now just copies g++$(exeext) over.
kono
parents:
diff changeset
121 * g++spec.c: New file.
kono
parents:
diff changeset
122 * g++.c: Removed file.
kono
parents:
diff changeset
123
kono
parents:
diff changeset
124 Tue Nov 26 19:01:09 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
125
kono
parents:
diff changeset
126 * cvt.c (build_up_reference): Arrange for any temporary values
kono
parents:
diff changeset
127 that have been keep in registers until now to be put into memory.
kono
parents:
diff changeset
128
kono
parents:
diff changeset
129 Mon Nov 25 15:16:41 1996 Kaveh R. Ghazi <ghazi@caip.rutgers.edu>
kono
parents:
diff changeset
130
kono
parents:
diff changeset
131 * Make-lang.in (c++.stage[1234]): Depend upon stage[1-4]-start, so
kono
parents:
diff changeset
132 that make -j3 bootstrap works better.
kono
parents:
diff changeset
133
kono
parents:
diff changeset
134 Sun Nov 24 02:09:39 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
135
kono
parents:
diff changeset
136 * decl.c (pushtag): Do pushdecl for anon tags.
kono
parents:
diff changeset
137
kono
parents:
diff changeset
138 Thu Nov 21 16:30:24 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
139
kono
parents:
diff changeset
140 * typeck.c (c_expand_return): Fix logic.
kono
parents:
diff changeset
141 (unary_complex_lvalue): Avoid unused warning on address of INIT_EXPR.
kono
parents:
diff changeset
142
kono
parents:
diff changeset
143 Wed Nov 20 18:47:31 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
144
kono
parents:
diff changeset
145 * g++.c (main): Make sure arglist has a final NULL entry. Add
kono
parents:
diff changeset
146 PEXECUTE_LAST to the flags passed to pexecute, as otherwise
kono
parents:
diff changeset
147 stdin/stdout of the invoked program are redirected to
kono
parents:
diff changeset
148 nowheresville.
kono
parents:
diff changeset
149
kono
parents:
diff changeset
150 Tue Nov 19 16:12:44 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
151
kono
parents:
diff changeset
152 * decl.c (implicitly_declare): Set DECL_ARTIFICIAL.
kono
parents:
diff changeset
153
kono
parents:
diff changeset
154 Tue Nov 19 15:48:19 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
155
kono
parents:
diff changeset
156 * init.c (resolve_offset_ref): Handle obj.vfn better.
kono
parents:
diff changeset
157 * typeck.c (build_component_ref): Set TREE_TYPE on result from
kono
parents:
diff changeset
158 build_vfn_ref.
kono
parents:
diff changeset
159
kono
parents:
diff changeset
160 Tue Nov 19 13:14:33 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
161
kono
parents:
diff changeset
162 * typeck.c (convert_for_assignment): Also handle anachronistic
kono
parents:
diff changeset
163 implicit conversions from (::*)() to cv void*.
kono
parents:
diff changeset
164 * cvt.c (cp_convert_to_pointer): Likewise.
kono
parents:
diff changeset
165
kono
parents:
diff changeset
166 Mon Nov 18 17:05:26 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
167
kono
parents:
diff changeset
168 * lex.c (handle_cp_pragma): Fix bogus warning.
kono
parents:
diff changeset
169
kono
parents:
diff changeset
170 Mon Nov 18 16:10:43 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
171
kono
parents:
diff changeset
172 * cvt.c (cp_convert_to_pointer): Avoid thinking a POINTER_TYPE
kono
parents:
diff changeset
173 (METHOD_TYPE) is a TYPE_PTRMEMFUNC_P.
kono
parents:
diff changeset
174
kono
parents:
diff changeset
175 Thu Nov 14 23:18:17 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
176
kono
parents:
diff changeset
177 * class.c (finish_struct_1): Support DWARF2_DEBUG.
kono
parents:
diff changeset
178 * search.c (dfs_debug_mark): Likewise.
kono
parents:
diff changeset
179 * decl2.c (finish_vtable_vardecl): Likewise.
kono
parents:
diff changeset
180 * decl.c (pushtag, finish_enum): Likewise.
kono
parents:
diff changeset
181 * lex.c (check_newline): Use debug_* instead of calling *out
kono
parents:
diff changeset
182 functions directly.
kono
parents:
diff changeset
183
kono
parents:
diff changeset
184 Thu Nov 14 15:21:46 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
185
kono
parents:
diff changeset
186 * Make-lang.in (cplib2.ready): Add else clause to avoid problems
kono
parents:
diff changeset
187 on some picky hosts.
kono
parents:
diff changeset
188
kono
parents:
diff changeset
189 Wed Nov 13 12:32:07 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
190
kono
parents:
diff changeset
191 * class.c (finish_struct_1): A class has a non-trivial copy
kono
parents:
diff changeset
192 constructor if it has virtual functions.
kono
parents:
diff changeset
193
kono
parents:
diff changeset
194 * cvt.c (cp_convert): Always call a constructor.
kono
parents:
diff changeset
195
kono
parents:
diff changeset
196 * call.c (reference_binding): Still tack on a REF_BIND
kono
parents:
diff changeset
197 for bad conversions.
kono
parents:
diff changeset
198 (build_user_type_conversion_1): Propagate ICS_BAD_FLAG.
kono
parents:
diff changeset
199
kono
parents:
diff changeset
200 * typeck.c (convert_arguments): Pass LOOKUP_ONLYCONVERTING.
kono
parents:
diff changeset
201 (c_expand_return): Likewise.
kono
parents:
diff changeset
202 * typeck2.c (digest_init): Likewise for { }.
kono
parents:
diff changeset
203 * init.c (expand_aggr_init_1): Keep the CONSTRUCTOR handling.
kono
parents:
diff changeset
204 * cvt.c (cp_convert): Handle failure better.
kono
parents:
diff changeset
205
kono
parents:
diff changeset
206 Wed Nov 13 11:51:20 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
207
kono
parents:
diff changeset
208 * g++.c (main): Also set PEXECUTE_SEARCH, to make the invocation
kono
parents:
diff changeset
209 of GCC be path-relative.
kono
parents:
diff changeset
210
kono
parents:
diff changeset
211 Wed Nov 13 11:27:16 1996 Michael Meissner <meissner@tiktok.cygnus.com>
kono
parents:
diff changeset
212
kono
parents:
diff changeset
213 * Make-lang.in (g++-cross): G++-cross doesn't need version.o, but
kono
parents:
diff changeset
214 it does need choose-temp.o and pexecute.o.
kono
parents:
diff changeset
215
kono
parents:
diff changeset
216 Wed Nov 13 07:53:38 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
217
kono
parents:
diff changeset
218 * g++.c (error) [!HAVE_VPRINTF]: Put error back for the only time
kono
parents:
diff changeset
219 that we still use it.
kono
parents:
diff changeset
220 (P_tmpdir, R_OK, W_OK, X_OK) [__MSDOS__]: Delete unnecessary macros.
kono
parents:
diff changeset
221
kono
parents:
diff changeset
222 Wed Nov 13 02:00:26 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
223
kono
parents:
diff changeset
224 * init.c (expand_default_init): Avoid calling constructors to
kono
parents:
diff changeset
225 initialize reference temps.
kono
parents:
diff changeset
226
kono
parents:
diff changeset
227 * cvt.c (convert_to_reference): Fix.
kono
parents:
diff changeset
228
kono
parents:
diff changeset
229 Tue Nov 12 19:10:07 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
230
kono
parents:
diff changeset
231 * cvt.c (cp_convert): Simplify for flag_ansi_overloading.
kono
parents:
diff changeset
232 (convert_to_reference): Likewise.
kono
parents:
diff changeset
233 * typeck.c (convert_for_initialization): Likewise.
kono
parents:
diff changeset
234 * init.c (expand_default_init): Likewise.
kono
parents:
diff changeset
235 (expand_aggr_init_1): Likewise.
kono
parents:
diff changeset
236 * cp-tree.h (CONV_NONCONVERTING): Lose.
kono
parents:
diff changeset
237 * typeck.c (build_c_cast): Lose allow_nonconverting parm.
kono
parents:
diff changeset
238 * *.c: Adjust.
kono
parents:
diff changeset
239 * call.c (build_user_type_conversion_1): Assume LOOKUP_ONLYCONVERTING.
kono
parents:
diff changeset
240
kono
parents:
diff changeset
241 Tue Nov 12 16:29:04 1996 Brendan Kehoe <brendan@canuck.cygnus.com>
kono
parents:
diff changeset
242
kono
parents:
diff changeset
243 * pt.c (tsubst_expr): Reverse args to expand_start_catch_block.
kono
parents:
diff changeset
244
kono
parents:
diff changeset
245 Tue Nov 12 15:26:17 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
246
kono
parents:
diff changeset
247 * init.c (expand_aggr_init_1): Don't crash on non-constructor
kono
parents:
diff changeset
248 TARGET_EXPR.
kono
parents:
diff changeset
249
kono
parents:
diff changeset
250 Tue Nov 12 14:00:50 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
251
kono
parents:
diff changeset
252 * g++.c: Include gansidecl.h.
kono
parents:
diff changeset
253 (VPROTO, PVPROTO, VA_START): Delete.
kono
parents:
diff changeset
254 (choose_temp_base_try, choose_temp_base, perror_exec,
kono
parents:
diff changeset
255 run_dos) [__MSDOS__]: Delete fns.
kono
parents:
diff changeset
256 (pfatal_with_name): Delete fn.
kono
parents:
diff changeset
257 (temp_filename): Declare like in gcc.c.
kono
parents:
diff changeset
258 (pexecute, pwait, choose_temp_base): Declare from gcc.c.
kono
parents:
diff changeset
259 (error_count, signal_count): Define.
kono
parents:
diff changeset
260 (error): Delete both definitions.
kono
parents:
diff changeset
261 (PEXECUTE_{FIRST,LAST,SEARCH,VERBOSE}): Define from gcc.c.
kono
parents:
diff changeset
262 (pfatal_pexecute): Add fn from gcc.c.
kono
parents:
diff changeset
263 (main): Rename local VERBOSE var to VERBOSE_FLAG. Rewrite the
kono
parents:
diff changeset
264 code to use the pexecute stuff also used by gcc.c.
kono
parents:
diff changeset
265 (MIN_FATAL_STATUS): Define.
kono
parents:
diff changeset
266 * Make-lang.in (g++): Add dependency on and linking with
kono
parents:
diff changeset
267 choose-temp.o and pexecute.o.
kono
parents:
diff changeset
268
kono
parents:
diff changeset
269 * cp-tree.h: Include gansidecl.h.
kono
parents:
diff changeset
270 (STDIO_PROTO): Delete #undef/#define.
kono
parents:
diff changeset
271 * cvt.c (NULL): Delete #undef/#define.
kono
parents:
diff changeset
272 * expr.c (NULL): Likewise.
kono
parents:
diff changeset
273 * init.c (NULL): Likewise.
kono
parents:
diff changeset
274 * rtti.c (NULL): Likewise.
kono
parents:
diff changeset
275 * xref.c (NULL): Likewise.
kono
parents:
diff changeset
276
kono
parents:
diff changeset
277 * cp-tree.h (build_user_type_conversion): Add prototype.
kono
parents:
diff changeset
278 * call.c (build_user_type_conversion): Delete prototype. Correct
kono
parents:
diff changeset
279 decl of FLAGS arg to be an int.
kono
parents:
diff changeset
280 * cvt.c (build_user_type_conversion): Likewise.
kono
parents:
diff changeset
281
kono
parents:
diff changeset
282 Tue Nov 12 12:16:20 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
283
kono
parents:
diff changeset
284 * cp-tree.def: Add TRY_BLOCK and HANDLER.
kono
parents:
diff changeset
285 * except.c (expand_start_catch_block): Support templates.
kono
parents:
diff changeset
286 * parse.y (try_block, handler_seq): Likewise.
kono
parents:
diff changeset
287 * pt.c (tsubst_expr): Support TRY_BLOCK and HANDLER.
kono
parents:
diff changeset
288
kono
parents:
diff changeset
289 Mon Nov 11 13:57:31 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
290
kono
parents:
diff changeset
291 * pt.c (current_template_args): New fn.
kono
parents:
diff changeset
292 (push_template_decl): Use it.
kono
parents:
diff changeset
293 * decl.c (grokdeclarator): Use it.
kono
parents:
diff changeset
294
kono
parents:
diff changeset
295 * decl2.c (build_expr_from_tree): Dereference ref vars.
kono
parents:
diff changeset
296
kono
parents:
diff changeset
297 * decl.c (grokdeclarator): Generalize handling of TYPENAME_TYPEs in
kono
parents:
diff changeset
298 the decl-specifier-seq.
kono
parents:
diff changeset
299
kono
parents:
diff changeset
300 * decl.c (grok_op_properties): Don't force the type of a conversion
kono
parents:
diff changeset
301 op to be complete. Don't warn about converting to the same type
kono
parents:
diff changeset
302 for template instantiations.
kono
parents:
diff changeset
303
kono
parents:
diff changeset
304 * decl2.c (finish_file): Don't call instantiate_decl on synthesized
kono
parents:
diff changeset
305 methods.
kono
parents:
diff changeset
306
kono
parents:
diff changeset
307 Mon Nov 11 13:20:34 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
308
kono
parents:
diff changeset
309 * typeck.c (get_delta_difference): Remove previous bogusness.
kono
parents:
diff changeset
310 Don't give errors if force is set.
kono
parents:
diff changeset
311
kono
parents:
diff changeset
312 Fri Nov 8 17:38:44 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
313
kono
parents:
diff changeset
314 * decl2.c (finish_file): Don't emit debug info.
kono
parents:
diff changeset
315 * decl.c (pushdecl): Lose obsolete code.
kono
parents:
diff changeset
316 (grokdeclarator): Still do the long long thing after complaining.
kono
parents:
diff changeset
317 * search.c (note_debug_info_needed): Don't do anything if we're in a
kono
parents:
diff changeset
318 template.
kono
parents:
diff changeset
319 * method.c (synthesize_method): For non-local classes,
kono
parents:
diff changeset
320 push_to_top_level first.
kono
parents:
diff changeset
321
kono
parents:
diff changeset
322 Fri Nov 8 11:52:28 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
323
kono
parents:
diff changeset
324 * typeck.c (get_delta_difference): Add no_error parameter.
kono
parents:
diff changeset
325 (build_ptrmemfunc): Call get_delta_difference with no_error set;
kono
parents:
diff changeset
326 we don't want error messages when converting unrelated
kono
parents:
diff changeset
327 pointer-to-member functions.
kono
parents:
diff changeset
328
kono
parents:
diff changeset
329 Thu Nov 7 11:16:24 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
330
kono
parents:
diff changeset
331 * error.c (dump_expr): Improve the wording on error messages that
kono
parents:
diff changeset
332 involve pointer to member functions.
kono
parents:
diff changeset
333
kono
parents:
diff changeset
334 Tue Nov 5 17:12:05 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
335
kono
parents:
diff changeset
336 * cvt.c (cp_convert_to_pointer): Move code for conversions from
kono
parents:
diff changeset
337 (::*)() to void* or (*)() up a bit, so that we can convert from
kono
parents:
diff changeset
338 METHOD_TYPEs as well.
kono
parents:
diff changeset
339
kono
parents:
diff changeset
340 Tue Nov 5 14:54:17 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
341
kono
parents:
diff changeset
342 * rtti.c (get_tinfo_fn): Make sure 'type' is permanent.
kono
parents:
diff changeset
343 There are no 'member' types.
kono
parents:
diff changeset
344 (get_tinfo_fn_dynamic): Diagnose typeid of overloaded fn.
kono
parents:
diff changeset
345 (build_x_typeid): Handle errors.
kono
parents:
diff changeset
346
kono
parents:
diff changeset
347 Mon Nov 4 17:43:12 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
348
kono
parents:
diff changeset
349 * typeck.c (convert_for_assignment): Handle anachronistic implicit
kono
parents:
diff changeset
350 conversions from (::*)() to void* or (*)().
kono
parents:
diff changeset
351 * cvt.c (cp_convert_to_pointer): Likewise.
kono
parents:
diff changeset
352 (cp_convert_to_pointer_force): Remove cp_convert_to_pointer
kono
parents:
diff changeset
353 conversions from here.
kono
parents:
diff changeset
354 * decl2.c (lang_decode_option): Add -W{no-,}pmf-conversions.
kono
parents:
diff changeset
355 * lang-options.h: Likewise.
kono
parents:
diff changeset
356 * decl2.c (warn_pmf2ptr): Define.
kono
parents:
diff changeset
357 * cp-tree.h: Declare it.
kono
parents:
diff changeset
358 * typeck2.c (digest_init): Allow pmfs down into
kono
parents:
diff changeset
359 convert_for_initialization.
kono
parents:
diff changeset
360
kono
parents:
diff changeset
361 Sun Nov 3 09:43:00 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
362
kono
parents:
diff changeset
363 * typeck.c (c_expand_return): Fix for returning overloaded fn.
kono
parents:
diff changeset
364
kono
parents:
diff changeset
365 Fri Nov 1 08:53:17 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
366
kono
parents:
diff changeset
367 * cp-tree.h (DIRECT_BIND): Change from INDIRECT_BIND.
kono
parents:
diff changeset
368 * decl.c (grok_reference_init): Pass DIRECT_BIND.
kono
parents:
diff changeset
369 * cvt.c (build_up_reference): Don't mark 'this' addressable. Use
kono
parents:
diff changeset
370 DIRECT_BIND.
kono
parents:
diff changeset
371 * call.c (convert_like): Don't pass INDIRECT_BIND.
kono
parents:
diff changeset
372 * typeck.c (convert_arguments): Likewise.
kono
parents:
diff changeset
373 * typeck.c (mark_addressable): Allow &this if flag_this_is_variable.
kono
parents:
diff changeset
374
kono
parents:
diff changeset
375 Thu Oct 31 17:08:49 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
376
kono
parents:
diff changeset
377 * typeck.c (mark_addressable): Support TARGET_EXPR, unify with
kono
parents:
diff changeset
378 similar code in build_up_ref.
kono
parents:
diff changeset
379 * cvt.c (build_up_reference): Drastically simplify.
kono
parents:
diff changeset
380
kono
parents:
diff changeset
381 Mon Oct 28 12:45:05 1996 Jeffrey A Law <law@cygnus.com>
kono
parents:
diff changeset
382
kono
parents:
diff changeset
383 * typeck.c (signed_or_unsigned_type): If the given type already
kono
parents:
diff changeset
384 as the correct signedness, then just return it.
kono
parents:
diff changeset
385
kono
parents:
diff changeset
386 * typeck.c ({un,}signed_type): If can't do anything, call
kono
parents:
diff changeset
387 signed_or_unsigned_type.
kono
parents:
diff changeset
388
kono
parents:
diff changeset
389 Thu Oct 24 14:21:59 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
390
kono
parents:
diff changeset
391 * decl2.c (copy_assignment_arg_p): Don't buy the farm if
kono
parents:
diff changeset
392 current_class_type is NULL.
kono
parents:
diff changeset
393
kono
parents:
diff changeset
394 Wed Oct 23 00:43:10 1996 Jason Merrill <jason@gerbil.cygnus.com>
kono
parents:
diff changeset
395
kono
parents:
diff changeset
396 * class.c (finish_struct_1): Avoid empty structs by adding a field
kono
parents:
diff changeset
397 so layout_type gets the mode right.
kono
parents:
diff changeset
398
kono
parents:
diff changeset
399 * typeck.c (c_expand_return): Drastically simplify.
kono
parents:
diff changeset
400
kono
parents:
diff changeset
401 Mon Oct 21 22:34:02 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
402
kono
parents:
diff changeset
403 * typeck.c (decay_conversion): Handle overloaded methods.
kono
parents:
diff changeset
404
kono
parents:
diff changeset
405 Fri Oct 18 16:03:48 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
406
kono
parents:
diff changeset
407 * call.c (build_over_call): A TARGET_EXPR has side-effects.
kono
parents:
diff changeset
408
kono
parents:
diff changeset
409 Thu Oct 17 11:31:59 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
410
kono
parents:
diff changeset
411 * cvt.c (convert_to_pointer_force): Add code to support pointer to
kono
parents:
diff changeset
412 member function to pointer to function conversions.
kono
parents:
diff changeset
413 * init.c (resolve_offset_ref): Add code to allow faked up objects,
kono
parents:
diff changeset
414 ignoring them if they are not used, and giving an error, if they
kono
parents:
diff changeset
415 are needed.
kono
parents:
diff changeset
416 * typeck.c (get_member_function_from_ptrfunc): Fold e1 to improve
kono
parents:
diff changeset
417 code, and so that we can give an error, if we needed an object,
kono
parents:
diff changeset
418 and one was not provided.
kono
parents:
diff changeset
419 (build_c_cast): Don't call default_conversion when we want to
kono
parents:
diff changeset
420 convert to pointer to function from a METHOD_TYPE.
kono
parents:
diff changeset
421
kono
parents:
diff changeset
422 Mon Oct 14 00:28:51 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
423
kono
parents:
diff changeset
424 * Make-lang.in (cplib2.ready): Fix logic.
kono
parents:
diff changeset
425
kono
parents:
diff changeset
426 * decl.c (shadow_tag): Only complain about non-artificial function
kono
parents:
diff changeset
427 members.
kono
parents:
diff changeset
428
kono
parents:
diff changeset
429 * class.c (finish_struct_1): Add synthesized methods to TYPE_METHODS.
kono
parents:
diff changeset
430
kono
parents:
diff changeset
431 Fri Oct 11 16:12:40 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
432
kono
parents:
diff changeset
433 * expr.c (cplus_expand_expr): Pre-tweak call_target like
kono
parents:
diff changeset
434 expand_inline_function would.
kono
parents:
diff changeset
435
kono
parents:
diff changeset
436 * pt.c (mark_decl_instantiated): If extern_p, call
kono
parents:
diff changeset
437 mark_inline_for_output.
kono
parents:
diff changeset
438
kono
parents:
diff changeset
439 Thu Oct 10 15:58:08 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
440
kono
parents:
diff changeset
441 * typeck.c (unary_complex_lvalue): Add code to handle intermediate
kono
parents:
diff changeset
442 pmd conversions.
kono
parents:
diff changeset
443
kono
parents:
diff changeset
444 * typeck.c (get_delta_difference): Fix wording, as we can be used
kono
parents:
diff changeset
445 for pointer to data members.
kono
parents:
diff changeset
446
kono
parents:
diff changeset
447 Tue Oct 8 12:43:51 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
448
kono
parents:
diff changeset
449 * pt.c (tsubst): If the function decl isn't a member of this
kono
parents:
diff changeset
450 template, return a copy of the decl (including copying the
kono
parents:
diff changeset
451 lang-specific part) so we don't hose ourselves later.
kono
parents:
diff changeset
452
kono
parents:
diff changeset
453 Thu Oct 3 16:24:28 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
454
kono
parents:
diff changeset
455 * class.c (finish_struct): Remove DWARF-specific tag handling.
kono
parents:
diff changeset
456 * decl.c (pushtag): Likewise.
kono
parents:
diff changeset
457 (finish_function): Always clear DECL_ARGUMENTS on function decls with
kono
parents:
diff changeset
458 no saved RTX.
kono
parents:
diff changeset
459 * decl2.c (finish_file): Emit DWARF debugging info for static data
kono
parents:
diff changeset
460 members.
kono
parents:
diff changeset
461
kono
parents:
diff changeset
462 Wed Oct 2 21:58:01 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
463
kono
parents:
diff changeset
464 * decl.c (duplicate_decls): Make sure the old DECL_LANG_SPECIFIC
kono
parents:
diff changeset
465 isn't the same as the new one before we whack it.
kono
parents:
diff changeset
466
kono
parents:
diff changeset
467 Mon Sep 30 13:38:24 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
468
kono
parents:
diff changeset
469 * class.c, cp-tree.h, cvt.c, decl.c, decl2.c, gxx.gperf, hash.h,
kono
parents:
diff changeset
470 lex.c, method.c, parse.y, typeck.c, typeck2.c: Remove
kono
parents:
diff changeset
471 warn_traditional and warn_strict_prototypes; remove ancient
kono
parents:
diff changeset
472 'overload' code; remove references to flag_traditional.
kono
parents:
diff changeset
473
kono
parents:
diff changeset
474 Mon Sep 30 12:58:40 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
475
kono
parents:
diff changeset
476 * input.c (sub_getch): Handle 8-bit characters in string literals.
kono
parents:
diff changeset
477
kono
parents:
diff changeset
478 Sun Sep 29 03:12:01 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
479
kono
parents:
diff changeset
480 * tree.c (mapcar): Handle CONSTRUCTORs.
kono
parents:
diff changeset
481 (copy_to_permanent): Handle expression_obstack properly.
kono
parents:
diff changeset
482
kono
parents:
diff changeset
483 * Make-lang.in (cplib2.txt): Also depend on the headers.
kono
parents:
diff changeset
484
kono
parents:
diff changeset
485 * rtti.c (get_tinfo_var): Don't assume that POINTER_SIZE ==
kono
parents:
diff changeset
486 INT_TYPE_SIZE.
kono
parents:
diff changeset
487 (expand_class_desc): Use USItype for offset field.
kono
parents:
diff changeset
488 * tinfo.h (struct __class_type_info): Likewise.
kono
parents:
diff changeset
489
kono
parents:
diff changeset
490 * method.c (build_overload_int): TYPE_PRECISION should be applied
kono
parents:
diff changeset
491 to types.
kono
parents:
diff changeset
492
kono
parents:
diff changeset
493 Sat Sep 28 14:44:50 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
494
kono
parents:
diff changeset
495 * call.c (build_new_op): A COND_EXPR involving void must be a
kono
parents:
diff changeset
496 builtin.
kono
parents:
diff changeset
497
kono
parents:
diff changeset
498 Fri Sep 27 16:40:30 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
499
kono
parents:
diff changeset
500 * typeck.c (build_x_component_ref): New fn.
kono
parents:
diff changeset
501 (build_object_ref): Use it.
kono
parents:
diff changeset
502 * parse.y (primary): Use it.
kono
parents:
diff changeset
503 * decl2.c (build_expr_from_tree): Use it.
kono
parents:
diff changeset
504 * cp-tree.h: Declare it.
kono
parents:
diff changeset
505
kono
parents:
diff changeset
506 * decl.c (start_decl): Variable-sized arrays cannot be initialized.
kono
parents:
diff changeset
507 * error.c (dump_type_suffix): Handle variable arrays.
kono
parents:
diff changeset
508
kono
parents:
diff changeset
509 Fri Sep 27 13:14:05 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
510
kono
parents:
diff changeset
511 * Make-lang.in (exception.o): Put back compiling it with -fPIC.
kono
parents:
diff changeset
512
kono
parents:
diff changeset
513 Fri Sep 27 03:00:09 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
514
kono
parents:
diff changeset
515 * decl.c (lookup_name_real): Don't try to look up anything in a
kono
parents:
diff changeset
516 TYPENAME_TYPE.
kono
parents:
diff changeset
517
kono
parents:
diff changeset
518 * tinfo2.cc (__throw_type_match_rtti): Oops.
kono
parents:
diff changeset
519
kono
parents:
diff changeset
520 Thu Sep 26 22:11:05 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
521
kono
parents:
diff changeset
522 * Make-lang.in (exception.o): Use -fno-PIC for now.
kono
parents:
diff changeset
523
kono
parents:
diff changeset
524 Thu Sep 26 10:59:00 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
525
kono
parents:
diff changeset
526 * rtti.c (build_dynamic_cast): Pass tinfo fns rather than
kono
parents:
diff changeset
527 calling them.
kono
parents:
diff changeset
528 (get_tinfo_fn_dynamic): Extracted from build_typeid.
kono
parents:
diff changeset
529 * tinfo2.cc (__dynamic_cast): Adjust.
kono
parents:
diff changeset
530
kono
parents:
diff changeset
531 * rtti.c (build_typeid): Use resolves_to_fixed_type_p.
kono
parents:
diff changeset
532 (build_x_typeid): Likewise.
kono
parents:
diff changeset
533
kono
parents:
diff changeset
534 * parse.y: Call build_x_typeid instead of build_typeid.
kono
parents:
diff changeset
535 * cp-tree.def: Add TYPEID_EXPR.
kono
parents:
diff changeset
536 * pt.c (tsubst_copy): Handle typeid.
kono
parents:
diff changeset
537 * decl2.c (build_expr_from_tree): Likewise.
kono
parents:
diff changeset
538 * rtti.c (build_x_typeid): Throw bad_typeid from here.
kono
parents:
diff changeset
539 (build_typeid): Not here.
kono
parents:
diff changeset
540 * cp-tree.h: Declare build_x_typeid.
kono
parents:
diff changeset
541
kono
parents:
diff changeset
542 Wed Sep 25 17:26:16 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
543
kono
parents:
diff changeset
544 * call.c (convert_like): Pull out constant values.
kono
parents:
diff changeset
545
kono
parents:
diff changeset
546 * tree.c (mapcar): Use build_cplus_array_type, not build_array_type.
kono
parents:
diff changeset
547
kono
parents:
diff changeset
548 Wed Sep 25 17:28:53 1996 Michael Meissner <meissner@tiktok.cygnus.com>
kono
parents:
diff changeset
549
kono
parents:
diff changeset
550 * decl.c (init_decl_processing): Create short int types before
kono
parents:
diff changeset
551 creating size_t in case a machine description needs to use
kono
parents:
diff changeset
552 unsigned short for size_t.
kono
parents:
diff changeset
553
kono
parents:
diff changeset
554 Tue Sep 24 18:18:44 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
555
kono
parents:
diff changeset
556 * Make-lang.in (exception.o): Turn off pic.
kono
parents:
diff changeset
557
kono
parents:
diff changeset
558 * tinfo2.cc (__throw_type_match_rtti): Fix cv-variants of the same
kono
parents:
diff changeset
559 type, multi-level ptr conversions.
kono
parents:
diff changeset
560
kono
parents:
diff changeset
561 * rtti.c (call_void_fn): Renamed and genericized from throw_bad_cast.
kono
parents:
diff changeset
562 (throw_bad_cast): Use it.
kono
parents:
diff changeset
563 (throw_bad_typeid): New fn.
kono
parents:
diff changeset
564 (build_typeid): Throw bad_typeid as needed.
kono
parents:
diff changeset
565 Use build_call.
kono
parents:
diff changeset
566 (synthesize_tinfo_fn): Handle functions and arrays before checking
kono
parents:
diff changeset
567 for cv-quals.
kono
parents:
diff changeset
568
kono
parents:
diff changeset
569 * Remove .h from standard C++ headers, add new.h, move into inc
kono
parents:
diff changeset
570 subdirectory.
kono
parents:
diff changeset
571
kono
parents:
diff changeset
572 * exception*: Remove pointer from object, constructors. Add
kono
parents:
diff changeset
573 default exception::what that uses type_info::name. Add
kono
parents:
diff changeset
574 __throw_bad_typeid.
kono
parents:
diff changeset
575
kono
parents:
diff changeset
576 * init.c (build_new): Don't add a cookie to new (void *) T[2].
kono
parents:
diff changeset
577
kono
parents:
diff changeset
578 Mon Sep 23 15:21:53 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
579
kono
parents:
diff changeset
580 * Make-lang.in: Building C++ code depends on cc1plus.
kono
parents:
diff changeset
581
kono
parents:
diff changeset
582 Mon Sep 23 12:38:40 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
583
kono
parents:
diff changeset
584 * decl.c (struct saved_scope): Declare PROCESSING_TEMPLATE_DECL as
kono
parents:
diff changeset
585 a HOST_WIDE_INT, not a tree.
kono
parents:
diff changeset
586
kono
parents:
diff changeset
587 Mon Sep 23 12:36:02 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
588
kono
parents:
diff changeset
589 * exception.cc: Don't include <stdlib.h>.
kono
parents:
diff changeset
590
kono
parents:
diff changeset
591 * Make-lang.in (c++.clean): Remove cplib2.*.
kono
parents:
diff changeset
592
kono
parents:
diff changeset
593 Mon Sep 23 09:42:19 1996 Doug Evans <dje@canuck.cygnus.com>
kono
parents:
diff changeset
594
kono
parents:
diff changeset
595 * parse.y (component_decl_1, component_costructor_declarator case):
kono
parents:
diff changeset
596 Pass attributes/prefix_attributes in tree list.
kono
parents:
diff changeset
597
kono
parents:
diff changeset
598 Mon Sep 23 01:18:50 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
599
kono
parents:
diff changeset
600 * tinfo{,2}.cc: #include <stddef.h> instead of <stdlib.h>.
kono
parents:
diff changeset
601
kono
parents:
diff changeset
602 Sun Sep 22 05:31:22 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
603
kono
parents:
diff changeset
604 * lex.c (do_identifier): Don't do deferred lookup in a template
kono
parents:
diff changeset
605 header.
kono
parents:
diff changeset
606
kono
parents:
diff changeset
607 * typeck2.c (store_init_value): Oops.
kono
parents:
diff changeset
608
kono
parents:
diff changeset
609 * new.{h,cc}, exception.{h,cc}, typeinfo.h, tinfo{2.cc,.cc,.h}:
kono
parents:
diff changeset
610 New files for C++ lang-support library.
kono
parents:
diff changeset
611 * Make-lang.in (CXX_EXTRA_HEADERS): Define.
kono
parents:
diff changeset
612 (CXX_LIB2FUNCS): Define.
kono
parents:
diff changeset
613 And rules for building the C++ lang-support code.
kono
parents:
diff changeset
614 * config-lang.in (headers): Define.
kono
parents:
diff changeset
615 (lib2funcs): Define.
kono
parents:
diff changeset
616
kono
parents:
diff changeset
617 Sat Sep 21 19:17:28 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
618
kono
parents:
diff changeset
619 * decl2.c (build_expr_from_tree): If CONSTRUCTOR has a type, call
kono
parents:
diff changeset
620 digest_init.
kono
parents:
diff changeset
621 * pt.c (tsubst_copy): Compute type for CONSTRUCTOR.
kono
parents:
diff changeset
622 * typeck2.c (store_init_value): Check for initializing pmf with { }
kono
parents:
diff changeset
623 here.
kono
parents:
diff changeset
624 (process_init_constructor): Not here.
kono
parents:
diff changeset
625
kono
parents:
diff changeset
626 Thu Sep 19 16:41:07 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
627
kono
parents:
diff changeset
628 * pt.c (begin_template_parm_list): Increment
kono
parents:
diff changeset
629 processing_template_decl here.
kono
parents:
diff changeset
630 (end_template_parm_list): Not here.
kono
parents:
diff changeset
631 (process_template_parm): No need to add 1 to it now.
kono
parents:
diff changeset
632 * *.c: Use processing_template_decl instead of current_template_parms
kono
parents:
diff changeset
633 to check for being in a template.
kono
parents:
diff changeset
634
kono
parents:
diff changeset
635 * pt.c (uses_template_parms): Handle SCOPE_REF. Fix CONSTRUCTOR.
kono
parents:
diff changeset
636 (tsubst_copy): Handle CONSTRUCTOR.
kono
parents:
diff changeset
637 (instantiate_decl): Set up context properly for variables.
kono
parents:
diff changeset
638 * decl2.c (build_expr_from_tree): Handle CONSTRUCTOR.
kono
parents:
diff changeset
639 * class.c (finish_struct): Reverse CLASSTYPE_TAGS.
kono
parents:
diff changeset
640
kono
parents:
diff changeset
641 Wed Sep 18 13:30:20 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
642
kono
parents:
diff changeset
643 * lex.c (enum tree_node_kind) [GATHER_STATISTICS]: Put the enum back.
kono
parents:
diff changeset
644
kono
parents:
diff changeset
645 Wed Sep 18 04:24:07 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
646
kono
parents:
diff changeset
647 * method.c (make_thunk): Call comdat_linkage before setting the
kono
parents:
diff changeset
648 TREE_CODE.
kono
parents:
diff changeset
649
kono
parents:
diff changeset
650 * decl2.c (comdat_linkage): Use make_decl_one_only.
kono
parents:
diff changeset
651 (import_export_decl): Likewise.
kono
parents:
diff changeset
652 * decl.c (init_decl_processing): Check supports_one_only instead of
kono
parents:
diff changeset
653 SUPPORTS_WEAK.
kono
parents:
diff changeset
654
kono
parents:
diff changeset
655 Sat Sep 14 08:34:41 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
656
kono
parents:
diff changeset
657 * decl2.c (grokfield): Tighten checking for access decls.
kono
parents:
diff changeset
658
kono
parents:
diff changeset
659 * decl.c (make_typename_type): Resolve references to
kono
parents:
diff changeset
660 current_class_type. Set CLASSTYPE_GOT_SEMICOLON.
kono
parents:
diff changeset
661 (lookup_name_real): Types that depend on a template parameter get
kono
parents:
diff changeset
662 an implicit 'typename' unless they're in the current scope.
kono
parents:
diff changeset
663 (start_decl_1): We don't care about incomplete types that depend
kono
parents:
diff changeset
664 on a template parm.
kono
parents:
diff changeset
665 (grokdeclarator): Resolve 'typename's in the type specifier that
kono
parents:
diff changeset
666 refer to members of the current scope.
kono
parents:
diff changeset
667
kono
parents:
diff changeset
668 * call.c (build_over_call): Remove 'inline called before
kono
parents:
diff changeset
669 definition' diagnostic.
kono
parents:
diff changeset
670 (build_method_call): Likewise.
kono
parents:
diff changeset
671 * decl.c (duplicate_decls): Downgrade 'used before declared
kono
parents:
diff changeset
672 inline' to a warning, only with -Winline.
kono
parents:
diff changeset
673
kono
parents:
diff changeset
674 Fri Sep 13 17:31:40 1996 Stan Shebs <shebs@andros.cygnus.com>
kono
parents:
diff changeset
675
kono
parents:
diff changeset
676 * mpw-make.sed: Fix include paths, add @DASH_C_FLAG@ to compile.
kono
parents:
diff changeset
677
kono
parents:
diff changeset
678 Wed Sep 11 22:38:13 1996 Gerald Baumgartner <gb@cs.purdue.edu>
kono
parents:
diff changeset
679
kono
parents:
diff changeset
680 * call.c (build_method_call): When calling a signature
kono
parents:
diff changeset
681 default implementation, as in other cases, let instance_ptr simply
kono
parents:
diff changeset
682 be instance.
kono
parents:
diff changeset
683
kono
parents:
diff changeset
684 Wed Sep 11 22:14:44 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
685
kono
parents:
diff changeset
686 * parse.y (simple_stmt): Cleanup and use do_poplevel ().
kono
parents:
diff changeset
687
kono
parents:
diff changeset
688 Wed Sep 11 22:10:48 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
689
kono
parents:
diff changeset
690 * except.c (expand_start_catch_block): Add a pushlevel so that -g
kono
parents:
diff changeset
691 works on hppa and SPARC.
kono
parents:
diff changeset
692
kono
parents:
diff changeset
693 Wed Sep 11 10:18:06 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
694
kono
parents:
diff changeset
695 * typeck.c (build_indirect_ref): Catch PTR being an error_mark_node.
kono
parents:
diff changeset
696
kono
parents:
diff changeset
697 Mon Sep 9 19:51:14 1996 Gerald Baumgartner <gb@cs.purdue.edu>
kono
parents:
diff changeset
698
kono
parents:
diff changeset
699 * call.c (build_over_call): Check first whether DECL_CONTEXT exists
kono
parents:
diff changeset
700 before testing whether it's a signature.
kono
parents:
diff changeset
701
kono
parents:
diff changeset
702 Sun Sep 8 16:06:57 1996 Gerald Baumgartner <gb@cs.purdue.edu>
kono
parents:
diff changeset
703
kono
parents:
diff changeset
704 * call.c (build_new_method_call): Don't complain about signature
kono
parents:
diff changeset
705 pointers and references not being an aggr type.
kono
parents:
diff changeset
706 (build_this): If a signature pointer or reference was passed in,
kono
parents:
diff changeset
707 just return it.
kono
parents:
diff changeset
708 (build_new_method_call): If instance is a signature pointer, set
kono
parents:
diff changeset
709 basetype to the signature type of instance.
kono
parents:
diff changeset
710 * sig.c (build_signature_method_call): Deleted basetype and
kono
parents:
diff changeset
711 instance parameters, they can be found as the DECL_CONTEXT of
kono
parents:
diff changeset
712 function and as the first argument passed in.
kono
parents:
diff changeset
713 * cp-tree.h: Changed declaration of build_signature_method_call.
kono
parents:
diff changeset
714 * call.c (build_method_call): Deleted first two arguments in call
kono
parents:
diff changeset
715 of build_signature_method_call.
kono
parents:
diff changeset
716 (build_over_call): Added call to build_signature_method_call.
kono
parents:
diff changeset
717
kono
parents:
diff changeset
718 Thu Sep 5 16:51:28 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
719
kono
parents:
diff changeset
720 * typeck.c (build_c_cast): Don't tack a non_lvalue_expr onto a
kono
parents:
diff changeset
721 target_expr.
kono
parents:
diff changeset
722
kono
parents:
diff changeset
723 Thu Sep 5 10:05:38 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
724
kono
parents:
diff changeset
725 * cvt.c (convert_to_reference): Use %#T, not %#D, for error.
kono
parents:
diff changeset
726
kono
parents:
diff changeset
727 Wed Sep 4 17:16:09 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
728
kono
parents:
diff changeset
729 * except.c (expand_start_try_stmts): Move to except.c in the backend.
kono
parents:
diff changeset
730 (expand_end_try_stmts): Remove.
kono
parents:
diff changeset
731
kono
parents:
diff changeset
732 * init.c (perform_member_init): Use add_partial_entry () instead
kono
parents:
diff changeset
733 of directly manipulating lists.
kono
parents:
diff changeset
734 (emit_base_init): Likewise.
kono
parents:
diff changeset
735
kono
parents:
diff changeset
736 Wed Sep 4 12:14:36 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
737
kono
parents:
diff changeset
738 * except.c (expand_exception_blocks): Always make sure USE and
kono
parents:
diff changeset
739 CLOBBER insns that came at the end still do, the backend relies
kono
parents:
diff changeset
740 upon this.
kono
parents:
diff changeset
741
kono
parents:
diff changeset
742 Wed Sep 4 07:44:48 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
743
kono
parents:
diff changeset
744 * call.c (build_over_call): We can only use a TARGET_EXPR of the
kono
parents:
diff changeset
745 right type.
kono
parents:
diff changeset
746
kono
parents:
diff changeset
747 Tue Sep 3 19:26:05 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
748
kono
parents:
diff changeset
749 * cvt.c (convert_to_reference): Revert last change, don't complain
kono
parents:
diff changeset
750 about temp without target decl.
kono
parents:
diff changeset
751
kono
parents:
diff changeset
752 Tue Sep 3 10:22:56 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
753
kono
parents:
diff changeset
754 * decl.c (grokdeclarator): Don't core dump when void() is given.
kono
parents:
diff changeset
755
kono
parents:
diff changeset
756 Tue Sep 3 02:38:56 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
757
kono
parents:
diff changeset
758 * decl.c (copy_args_p): Don't crash.
kono
parents:
diff changeset
759
kono
parents:
diff changeset
760 Fri Aug 30 14:26:57 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
761
kono
parents:
diff changeset
762 * pt.c (tsubst): And support template args inside the exception
kono
parents:
diff changeset
763 specification.
kono
parents:
diff changeset
764
kono
parents:
diff changeset
765 * pt.c (tsubst): Add support for exception specifications in
kono
parents:
diff changeset
766 template functions.
kono
parents:
diff changeset
767
kono
parents:
diff changeset
768 Fri Aug 30 10:01:55 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
769
kono
parents:
diff changeset
770 * cp-tree.def (DECL_STMT): Eliminate the throw spec field, only 3
kono
parents:
diff changeset
771 fields now.
kono
parents:
diff changeset
772 * cp-tree.h (start_decl): Eliminate the throw spec parameter.
kono
parents:
diff changeset
773 (start_function): Likewise.
kono
parents:
diff changeset
774 (start_method): Likewise.
kono
parents:
diff changeset
775 (grokfield): Likewise.
kono
parents:
diff changeset
776 (make_call_declarator): Add throw spec parameter.
kono
parents:
diff changeset
777 (set_quals_and_spec): Add routine.
kono
parents:
diff changeset
778 * lex.c (set_quals_and_spec): Likewise.
kono
parents:
diff changeset
779 * decl.h (grokdeclarator): Eliminate the throw spec parameter.
kono
parents:
diff changeset
780 * decl.c (shadow_tag): Eliminate the throw spec parameter to
kono
parents:
diff changeset
781 grokdeclarator.
kono
parents:
diff changeset
782 (groktypename): Likewise.
kono
parents:
diff changeset
783 (start_decl): Eliminate the throw spec parameter. Eliminate the
kono
parents:
diff changeset
784 throw spec parameter to grokdeclarator. Eliminate the throw spec
kono
parents:
diff changeset
785 field in DECL_STMT.
kono
parents:
diff changeset
786 (cp_finish_decl): Eliminate the throw spec field in DECL_STMT.
kono
parents:
diff changeset
787 (grokfndecl): Remove useless set of raises.
kono
parents:
diff changeset
788 (grokdeclarator): Eliminate the throw spec parameter. Eliminate
kono
parents:
diff changeset
789 the throw spec parameter to start_decl. Pull the throw spec out
kono
parents:
diff changeset
790 of the call declarator.
kono
parents:
diff changeset
791 (grokparms): Eliminate the throw spec parameter to grokdeclarator.
kono
parents:
diff changeset
792 (start_function): Eliminate the throw spec parameter. Eliminate
kono
parents:
diff changeset
793 the throw spec parameter to grokdeclarator.
kono
parents:
diff changeset
794 (start_method): Likewise.
kono
parents:
diff changeset
795 * decl2.c (grokfield): Likewise.
kono
parents:
diff changeset
796 (grokbitfield): Eliminate the throw spec parameter to grokdeclarator.
kono
parents:
diff changeset
797 (grokoptypename): Likewise.
kono
parents:
diff changeset
798 (finish_file): Eliminate the throw spec parameter to
kono
parents:
diff changeset
799 start_function. Add throw spec to make_call_declarator.
kono
parents:
diff changeset
800 * except.c (init_exception_processing): Add throw spec to
kono
parents:
diff changeset
801 make_call_declarator. Eliminate the throw spec parameter to
kono
parents:
diff changeset
802 start_decl.
kono
parents:
diff changeset
803 (expand_start_catch_block): Eliminate the throw spec parameter to
kono
parents:
diff changeset
804 grokdeclarator.
kono
parents:
diff changeset
805 (expand_builtin_throw): Add throw spec to make_call_declarator.
kono
parents:
diff changeset
806 Eliminate the throw spec parameter to start_function.
kono
parents:
diff changeset
807 (start_anon_func): Likewise.
kono
parents:
diff changeset
808 * lex.c (make_call_declarator): Add throw spec parameter.
kono
parents:
diff changeset
809 (set_quals_and_spec): New routine.
kono
parents:
diff changeset
810 (cons_up_default_function): Add throw spec to make_call_declarator.
kono
parents:
diff changeset
811 Eliminate the throw spec parameter to grokfield.
kono
parents:
diff changeset
812 * method.c (synthesize_method): Eliminate the throw spec parameter
kono
parents:
diff changeset
813 to start_function.
kono
parents:
diff changeset
814 * pt.c (process_template_parm): Eliminate the throw spec parameter
kono
parents:
diff changeset
815 to grokdeclarator.
kono
parents:
diff changeset
816 (tsubst): Add throw spec to make_call_declarator.
kono
parents:
diff changeset
817 (tsubst_expr): Eliminate the throw spec parameter to start_decl.
kono
parents:
diff changeset
818 (do_function_instantiation): Eliminate the throw spec parameter to
kono
parents:
diff changeset
819 grokdeclarator. Eliminate the throw spec parameter to
kono
parents:
diff changeset
820 start_function.
kono
parents:
diff changeset
821 * rtti.c (synthesize_tinfo_fn): Eliminate the throw spec parameter
kono
parents:
diff changeset
822 to start_function.
kono
parents:
diff changeset
823 * parse.y (datadef): Remove non-winning optimization.
kono
parents:
diff changeset
824 (decl): Likewise.
kono
parents:
diff changeset
825 (fndef): Remove ambiguous error productions uncovered by grammar
kono
parents:
diff changeset
826 fixing.
kono
parents:
diff changeset
827 (constructor_declarator): Add exception_specification_opt here.
kono
parents:
diff changeset
828 (component_constructor_declarator): Likewise.
kono
parents:
diff changeset
829 (direct_after_type_declarator): Likewise.
kono
parents:
diff changeset
830 (complex_direct_notype_declarator): Likewise.
kono
parents:
diff changeset
831 (direct_abstract_declarator): Likewise.
kono
parents:
diff changeset
832 (fn.def1): Remove exception_specification_opt.
kono
parents:
diff changeset
833 (fn.def2): Likewise.
kono
parents:
diff changeset
834 (condition): Likewise.
kono
parents:
diff changeset
835 (initdcl0): Likewise.
kono
parents:
diff changeset
836 (initdcl): Likewise.
kono
parents:
diff changeset
837 (notype_initdcl0): Likewise.
kono
parents:
diff changeset
838 (nomods_initdcl0): Likewise.
kono
parents:
diff changeset
839 (component_decl_1): Likewise.
kono
parents:
diff changeset
840 (component_declarator): Likewise.
kono
parents:
diff changeset
841 (after_type_component_declarator0): Likewise.
kono
parents:
diff changeset
842 (after_type_component_declarator): Likewise.
kono
parents:
diff changeset
843 (notype_component_declarator): Likewise.
kono
parents:
diff changeset
844
kono
parents:
diff changeset
845 Wed Aug 28 01:40:30 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
846
kono
parents:
diff changeset
847 * call.c (build_over_call): Also use an INIT_EXPR when
kono
parents:
diff changeset
848 initializing anything from an rvalue.
kono
parents:
diff changeset
849
kono
parents:
diff changeset
850 * call.c (build_over_call): Call stabilize_reference when building
kono
parents:
diff changeset
851 an INIT_EXPR instead of calling the copy ctor.
kono
parents:
diff changeset
852
kono
parents:
diff changeset
853 * call.c (joust): Extend the previous change to all comparisons.
kono
parents:
diff changeset
854
kono
parents:
diff changeset
855 * decl2.c, method.c, lex.c: Use MAKE_DECL_ONE_ONLY and
kono
parents:
diff changeset
856 NO_LINKAGE_HEURISTICS.
kono
parents:
diff changeset
857
kono
parents:
diff changeset
858 * decl2.c (finish_file): Emit any statics that weren't already.
kono
parents:
diff changeset
859
kono
parents:
diff changeset
860 * typeck.c (build_static_cast): Implement.
kono
parents:
diff changeset
861 * tree.c (build_cplus_new): Handle getting a TARGET_EXPR.
kono
parents:
diff changeset
862 * decl.c (grokparms): Use can_convert_arg instead of
kono
parents:
diff changeset
863 implicit_conversion directly.
kono
parents:
diff changeset
864 (copy_args_p): New fn.
kono
parents:
diff changeset
865 * cvt.c (convert_to_reference): Don't complain about temp with
kono
parents:
diff changeset
866 static_cast.
kono
parents:
diff changeset
867 (build_up_reference): Handle TARGET_EXPRs.
kono
parents:
diff changeset
868 * call.c (build_over_call): Elide unnecessary temps.
kono
parents:
diff changeset
869 (can_convert*): Use new overloading code.
kono
parents:
diff changeset
870
kono
parents:
diff changeset
871 Tue Aug 27 13:12:21 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
872
kono
parents:
diff changeset
873 * call.c: Move TYPE_PTR*_MACROS ...
kono
parents:
diff changeset
874 * cp-tree.h: To here.
kono
parents:
diff changeset
875 * typeck.c (build_reinterpret_cast): Implement.
kono
parents:
diff changeset
876
kono
parents:
diff changeset
877 * call.c (add_builtin_candidate): Use TYPE_PTROB_P instead of
kono
parents:
diff changeset
878 ptr_complete_ob.
kono
parents:
diff changeset
879 (joust): If we're comparing a function to a builtin and the worst
kono
parents:
diff changeset
880 conversion for the builtin is worse than the worst conversion for the
kono
parents:
diff changeset
881 function, take the function.
kono
parents:
diff changeset
882
kono
parents:
diff changeset
883 * typeck.c (build_const_cast): Implement.
kono
parents:
diff changeset
884 (comp_ptr_ttypes_const): Like comp_ptr_ttypes, for const_cast.
kono
parents:
diff changeset
885 (comp_ptr_ttypes_reinterpret): Like cpt, for reinterpret_cast.
kono
parents:
diff changeset
886
kono
parents:
diff changeset
887 Tue Aug 27 13:14:58 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
888
kono
parents:
diff changeset
889 * rtti.c (build_dynamic_cast): Don't try to dereference exprtype
kono
parents:
diff changeset
890 too early. Make sure we explode if exprtype turns out to be a
kono
parents:
diff changeset
891 NULL_TREE when it shouldn't be.
kono
parents:
diff changeset
892
kono
parents:
diff changeset
893 Tue Aug 27 10:56:21 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
894
kono
parents:
diff changeset
895 * cp-tree.h: New routine make_call_declarator.
kono
parents:
diff changeset
896 * lex.c (make_call_declarator): Define it.
kono
parents:
diff changeset
897 * except.c (init_exception_processing): Use it.
kono
parents:
diff changeset
898 (expand_builtin_throw): Likewise.
kono
parents:
diff changeset
899 (start_anon_func): Likewise.
kono
parents:
diff changeset
900 * decl2.c (finish_file): Likewise.
kono
parents:
diff changeset
901 * lex.c (cons_up_default_function): Likewise.
kono
parents:
diff changeset
902 * parse.y: Likewise.
kono
parents:
diff changeset
903 * pt.c (tsubst): Likewise.
kono
parents:
diff changeset
904
kono
parents:
diff changeset
905 Mon Aug 26 17:40:03 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
906
kono
parents:
diff changeset
907 * decl2.c (groktypefield): Remove unused code.
kono
parents:
diff changeset
908
kono
parents:
diff changeset
909 Mon Aug 26 17:00:33 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
910
kono
parents:
diff changeset
911 * gxx.gperf: Change TYPE_QUAL into CV_QUALIFIER.
kono
parents:
diff changeset
912 * parse.y: Likewise. Change maybe_type_qual into maybe_cv_qualifier.
kono
parents:
diff changeset
913 Change type_quals into cv_qualifiers. Change nonempty_type_quals into
kono
parents:
diff changeset
914 nonempty_cv_qualifiers.
kono
parents:
diff changeset
915 * hash.h: Rebuild.
kono
parents:
diff changeset
916
kono
parents:
diff changeset
917 * lex.c (make_pointer_declarator): Change type_quals into
kono
parents:
diff changeset
918 cv_qualifiers.
kono
parents:
diff changeset
919 (make_reference_declarator): Likewise.
kono
parents:
diff changeset
920
kono
parents:
diff changeset
921 Thu Aug 22 01:09:22 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
922
kono
parents:
diff changeset
923 * decl.c (start_function): Only check interface_* for templates
kono
parents:
diff changeset
924 with flag_alt_external_templates.
kono
parents:
diff changeset
925
kono
parents:
diff changeset
926 * call.c (build_new_op): Check for comparison of different enum types.
kono
parents:
diff changeset
927 (build_over_call): Fix arg # output.
kono
parents:
diff changeset
928
kono
parents:
diff changeset
929 * typeck.c (build_component_ref): Handle pre-found TYPE_DECL.
kono
parents:
diff changeset
930
kono
parents:
diff changeset
931 Wed Aug 21 00:13:15 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
932
kono
parents:
diff changeset
933 * call.c (build_new_op): Check for erroneous args.
kono
parents:
diff changeset
934
kono
parents:
diff changeset
935 * call.c (build_new_method_call): Add missing args to cp_error.
kono
parents:
diff changeset
936
kono
parents:
diff changeset
937 * tree.c (error_type): Don't print reference-to-array.
kono
parents:
diff changeset
938
kono
parents:
diff changeset
939 * typeck.c (convert_for_assignment): Don't say contravariance for
kono
parents:
diff changeset
940 removing const.
kono
parents:
diff changeset
941
kono
parents:
diff changeset
942 Tue Aug 20 13:23:00 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
943
kono
parents:
diff changeset
944 * call.c (build_over_call): Diagnose bad convs for `this'.
kono
parents:
diff changeset
945
kono
parents:
diff changeset
946 * lex.c (cons_up_default_function): Set DECL_ARTIFICIAL
kono
parents:
diff changeset
947 on _ctor_arg.
kono
parents:
diff changeset
948
kono
parents:
diff changeset
949 * call.c (convert_like): Handle bad convs.
kono
parents:
diff changeset
950 (build_over_call): Handle bad convs better.
kono
parents:
diff changeset
951
kono
parents:
diff changeset
952 * decl2.c: -fansi-overloading is now the default.
kono
parents:
diff changeset
953
kono
parents:
diff changeset
954 * call.c (build_new_method_call): Check for erroneous args.
kono
parents:
diff changeset
955
kono
parents:
diff changeset
956 * pt.c (instantiate_class_template): Propagate
kono
parents:
diff changeset
957 TYPE_USES_MULTIPLE_INHERITANCE.
kono
parents:
diff changeset
958
kono
parents:
diff changeset
959 Tue Aug 20 13:09:57 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
960
kono
parents:
diff changeset
961 * call.c (enforce_access): Add static to routine.
kono
parents:
diff changeset
962
kono
parents:
diff changeset
963 Sun Aug 18 14:35:54 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
964
kono
parents:
diff changeset
965 * call.c (build_user_type_conversion_1): Fix bad handling.
kono
parents:
diff changeset
966 (compare_ics): Likewise.
kono
parents:
diff changeset
967
kono
parents:
diff changeset
968 Sat Aug 17 21:54:11 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
969
kono
parents:
diff changeset
970 * call.c (standard_conversion): Oops.
kono
parents:
diff changeset
971
kono
parents:
diff changeset
972 Sat Aug 17 16:28:11 1996 Geoffrey Noer <noer@cygnus.com>
kono
parents:
diff changeset
973
kono
parents:
diff changeset
974 * g++.c: Update test for win32 (&& ! cygwin32).
kono
parents:
diff changeset
975
kono
parents:
diff changeset
976 Sat Aug 17 03:45:31 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
977
kono
parents:
diff changeset
978 * typeck.c (comp_ptr_ttypes_real): Handle OFFSET_TYPEs properly.
kono
parents:
diff changeset
979 (ptr_reasonably_similar): New fn.
kono
parents:
diff changeset
980 * call.c (BAD_RANK): New rank.
kono
parents:
diff changeset
981 (ICS_BAD_FLAG): New macro.
kono
parents:
diff changeset
982 (standard_conversion): Handle almost-right pointer conversions.
kono
parents:
diff changeset
983 (reference_binding): Handle bad rvalue bindings.
kono
parents:
diff changeset
984 (add_*_candidate): Stuff.
kono
parents:
diff changeset
985 (build_over_call): Pass bad conversions to convert_for_initialization.
kono
parents:
diff changeset
986 (compare_ics): Handle bad convs.
kono
parents:
diff changeset
987 (joust): Likewise.
kono
parents:
diff changeset
988
kono
parents:
diff changeset
989 Fri Aug 16 15:02:19 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
990
kono
parents:
diff changeset
991 * init.c (expand_vec_init): Use ptrdiff_type_node instead of
kono
parents:
diff changeset
992 integer_type_node when computing pointer offsets.
kono
parents:
diff changeset
993
kono
parents:
diff changeset
994 Fri Aug 16 01:28:32 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
995
kono
parents:
diff changeset
996 * tree.c (lvalue_type): New fn.
kono
parents:
diff changeset
997 (error_type): New fn.
kono
parents:
diff changeset
998 * call.c (op_error): Use error_type.
kono
parents:
diff changeset
999 (add_conv_candidate): Use lvalue_type.
kono
parents:
diff changeset
1000 (add_builtin_candidates): Likewise.
kono
parents:
diff changeset
1001 * error.c (args_as_string): Use error_type.
kono
parents:
diff changeset
1002
kono
parents:
diff changeset
1003 Thu Aug 15 17:27:13 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1004
kono
parents:
diff changeset
1005 * pt.c (instantiate_decl): Evaluate DECL_INITIAL of a VAR_DECL here.
kono
parents:
diff changeset
1006 (tsubst): Not here.
kono
parents:
diff changeset
1007
kono
parents:
diff changeset
1008 * decl.c (init_decl_processing): With -ansi, __null's type is the
kono
parents:
diff changeset
1009 signed integral type with the same number of bits as a pointer.
kono
parents:
diff changeset
1010 Introduce a new variable null_node for it.
kono
parents:
diff changeset
1011 * cp-tree.h: Adjust.
kono
parents:
diff changeset
1012 * call.c (null_ptr_cst_p): Adjust.
kono
parents:
diff changeset
1013
kono
parents:
diff changeset
1014 Thu Aug 15 17:09:54 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1015
kono
parents:
diff changeset
1016 * except.c (do_unwind): Mark %i7 as used on the SPARC so we can
kono
parents:
diff changeset
1017 optimize.
kono
parents:
diff changeset
1018
kono
parents:
diff changeset
1019 Thu Aug 15 01:36:49 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1020
kono
parents:
diff changeset
1021 * decl2.c (import_export_decl): Ignore #pragma interface for tinfo
kono
parents:
diff changeset
1022 fns of classes without virtual functions.
kono
parents:
diff changeset
1023
kono
parents:
diff changeset
1024 * call.c (add_function_candidate): Handle `this' specially.
kono
parents:
diff changeset
1025 (compare_ics): Likewise.
kono
parents:
diff changeset
1026
kono
parents:
diff changeset
1027 Tue Aug 13 12:16:10 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1028
kono
parents:
diff changeset
1029 * typeck.c (build_conditional_expr): Fix handling of __null.
kono
parents:
diff changeset
1030
kono
parents:
diff changeset
1031 * decl2.c (comdat_linkage): New fn.
kono
parents:
diff changeset
1032 (import_export_vtable): Use it.
kono
parents:
diff changeset
1033 (import_export_decl): Use it.
kono
parents:
diff changeset
1034 * method.c (make_thunk): Use it.
kono
parents:
diff changeset
1035
kono
parents:
diff changeset
1036 Mon Aug 12 00:09:18 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1037
kono
parents:
diff changeset
1038 * pt.c (end_template_decl): If we don't actually have parms, return.
kono
parents:
diff changeset
1039 * parse.y (template_header): Accept 'template <>'.
kono
parents:
diff changeset
1040
kono
parents:
diff changeset
1041 * errfn.c: Allow 5 args.
kono
parents:
diff changeset
1042
kono
parents:
diff changeset
1043 Sun Aug 11 15:20:58 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1044
kono
parents:
diff changeset
1045 * tree.c (make_temp_vec): New fn.
kono
parents:
diff changeset
1046 * pt.c (push_template_decl): Handle partial specs.
kono
parents:
diff changeset
1047 (instantiate_class_template): Likewise.
kono
parents:
diff changeset
1048 (more_specialized): Use get_bindings.
kono
parents:
diff changeset
1049 (more_specialized_class): New fn.
kono
parents:
diff changeset
1050 (get_class_bindings): New fn.
kono
parents:
diff changeset
1051 (most_specialized_class): New fn.
kono
parents:
diff changeset
1052 (do_function_instantiation): List candidates for ambiguous case.
kono
parents:
diff changeset
1053 * decl.c (duplicate_decls): Lose reference to DECL_TEMPLATE_MEMBERS.
kono
parents:
diff changeset
1054 (shadow_tag): Call push_template_decl for partial specializations.
kono
parents:
diff changeset
1055 * parse.y: Likewise.
kono
parents:
diff changeset
1056 * cp-tree.h (DECL_TEMPLATE_SPECIALIZATIONS): Replaces
kono
parents:
diff changeset
1057 DECL_TEMPLATE_MEMBERS.
kono
parents:
diff changeset
1058 * call.c (print_z_candidates): Reduce duplication.
kono
parents:
diff changeset
1059
kono
parents:
diff changeset
1060 Fri Aug 9 14:36:08 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1061
kono
parents:
diff changeset
1062 * decl2.c (lang_decode_option): Allow -fansi-overloading.
kono
parents:
diff changeset
1063
kono
parents:
diff changeset
1064 Thu Aug 8 17:04:18 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1065
kono
parents:
diff changeset
1066 * pt.c (get_bindings): New fn.
kono
parents:
diff changeset
1067 (most_specialized): Likewise.
kono
parents:
diff changeset
1068 (do_function_instantiation): Use them.
kono
parents:
diff changeset
1069 (add_maybe_template): New fn.
kono
parents:
diff changeset
1070 * cp-tree.h (DECL_MAYBE_TEMPLATE): New macro.
kono
parents:
diff changeset
1071 * call.c (build_new_op): Handle guiding decls.
kono
parents:
diff changeset
1072 (build_new_function_call): Likewise.
kono
parents:
diff changeset
1073 * decl2.c (finish_file): Likewise.
kono
parents:
diff changeset
1074
kono
parents:
diff changeset
1075 * decl2.c (mark_used): Do synthesis here.
kono
parents:
diff changeset
1076 * call.c (build_method_call): Not here.
kono
parents:
diff changeset
1077 (build_over_call): Or here.
kono
parents:
diff changeset
1078 * typeck.c (build_function_call_real): Or here.
kono
parents:
diff changeset
1079 * tree.c (bot_manip): Call mark_used on functions used in default
kono
parents:
diff changeset
1080 args.
kono
parents:
diff changeset
1081
kono
parents:
diff changeset
1082 Thu Aug 8 17:48:16 1996 Michael Meissner <meissner@tiktok.cygnus.com>
kono
parents:
diff changeset
1083
kono
parents:
diff changeset
1084 * decl2.c (import_export_vtable): Delete code that disabled vtable
kono
parents:
diff changeset
1085 heuristic on systems with ASM_OUTPUT_EXTERNAL.
kono
parents:
diff changeset
1086
kono
parents:
diff changeset
1087 Wed Aug 7 12:44:11 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1088
kono
parents:
diff changeset
1089 * typeck.c (build_x_function_call): Handle static call context
kono
parents:
diff changeset
1090 better.
kono
parents:
diff changeset
1091
kono
parents:
diff changeset
1092 * decl.c (finish_function): Set the DECL_CONTEXT of the result to
kono
parents:
diff changeset
1093 the function, not its outer block.
kono
parents:
diff changeset
1094
kono
parents:
diff changeset
1095 * call.c (build_field_call): Pass fields on to build_opfncall
kono
parents:
diff changeset
1096 regardless of TYPE_OVERLOADS_CALL_EXPR.
kono
parents:
diff changeset
1097 (build_method_call): Pass on to build_new_method_call sooner.
kono
parents:
diff changeset
1098
kono
parents:
diff changeset
1099 * typeck.c (build_ptrmemfunc): Just return what instantiate_type
kono
parents:
diff changeset
1100 gives us.
kono
parents:
diff changeset
1101 * class.c (instantiate_type): Don't put a POINTER_TYPE to
kono
parents:
diff changeset
1102 METHOD_TYPE on an expression. Also make a copy of rhs instead of
kono
parents:
diff changeset
1103 modifying it.
kono
parents:
diff changeset
1104
kono
parents:
diff changeset
1105 Tue Aug 6 12:58:46 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1106
kono
parents:
diff changeset
1107 * call.c (compare_ics): Handle qual_conv after lvalue_conv.
kono
parents:
diff changeset
1108 (add_builtin_candidate): Don't take enums for ++.
kono
parents:
diff changeset
1109 (build_new_method_call): Handle non-aggregates and field calls.
kono
parents:
diff changeset
1110 Move new overloading code from...
kono
parents:
diff changeset
1111 * cvt.c: Here.
kono
parents:
diff changeset
1112
kono
parents:
diff changeset
1113 * decl.c (grokparms): Don't check default args in templates.
kono
parents:
diff changeset
1114
kono
parents:
diff changeset
1115 Mon Aug 5 17:17:06 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1116
kono
parents:
diff changeset
1117 * cvt.c (build_new_op): Fix args to build_unary_op.
kono
parents:
diff changeset
1118 (add_builtin_candidates): Don't call type_promotes_to on float.
kono
parents:
diff changeset
1119
kono
parents:
diff changeset
1120 * decl.c (grokparms): Check the type of the default arg.
kono
parents:
diff changeset
1121
kono
parents:
diff changeset
1122 * cvt.c (build_new_op): Pass non-overloaded cases on rather than
kono
parents:
diff changeset
1123 returning NULL_TREE.
kono
parents:
diff changeset
1124
kono
parents:
diff changeset
1125 * typeck.c (build_x_binary_op): Avoid doing extra work.
kono
parents:
diff changeset
1126 (build_x_unary_op): Likewise.
kono
parents:
diff changeset
1127 (build_x_conditional_expr): Likewise.
kono
parents:
diff changeset
1128 * cvt.c (build_over_call): Return.
kono
parents:
diff changeset
1129 (add_builtin_candidate): Fix MEMBER_REF.
kono
parents:
diff changeset
1130 (build_new_op): Likewise.
kono
parents:
diff changeset
1131
kono
parents:
diff changeset
1132 Mon Aug 5 17:07:47 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1133
kono
parents:
diff changeset
1134 * method.c (build_overload_name): Put bug fix into code but leave
kono
parents:
diff changeset
1135 disabled for now so we can be bug compatible with older releases
kono
parents:
diff changeset
1136 that do repeats incorrectly. In the future, we can enable it.
kono
parents:
diff changeset
1137
kono
parents:
diff changeset
1138 Mon Aug 5 13:46:28 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1139
kono
parents:
diff changeset
1140 * cvt.c (convert_like): Don't call build_cplus_new twice.
kono
parents:
diff changeset
1141
kono
parents:
diff changeset
1142 * call.c, cp-tree.h, cvt.c, decl2.c, init.c, method.c, pt.c, typeck.c:
kono
parents:
diff changeset
1143 Control new overloading code with -fansi-overloading.
kono
parents:
diff changeset
1144
kono
parents:
diff changeset
1145 Sun Aug 4 15:29:11 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1146
kono
parents:
diff changeset
1147 * cvt.c (build_over_call): Call build_cplus_new.
kono
parents:
diff changeset
1148 * call.c (build_method_call): Likewise.
kono
parents:
diff changeset
1149 * typeck.c (build_function_call_real): Likewise.
kono
parents:
diff changeset
1150 (build_conditional_expr): If both operands are TARGET_EXPRs, wrap
kono
parents:
diff changeset
1151 the COND_EXPR in a TARGET_EXPR so they use the same slot.
kono
parents:
diff changeset
1152
kono
parents:
diff changeset
1153 * cvt.c (build_up_reference): Propagate INDIRECT_BIND to
kono
parents:
diff changeset
1154 recursive calls.
kono
parents:
diff changeset
1155 * typeck.c (complete_type): Propagate
kono
parents:
diff changeset
1156 TYPE_NEEDS_{CONSTRUCTING,DESTRUCTOR}.
kono
parents:
diff changeset
1157
kono
parents:
diff changeset
1158 Sat Aug 3 14:05:07 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1159
kono
parents:
diff changeset
1160 * cvt.c (joust): More ?: kludging. Sigh.
kono
parents:
diff changeset
1161 (build_over_call): Don't try to synthesize global fns.
kono
parents:
diff changeset
1162
kono
parents:
diff changeset
1163 * search.c (lookup_conversions): Use binfo marking.
kono
parents:
diff changeset
1164
kono
parents:
diff changeset
1165 Sat Aug 3 12:33:42 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1166
kono
parents:
diff changeset
1167 * search.c (build_mi_matrix): Use the correct value of cid
kono
parents:
diff changeset
1168 when determining the new mi_size.
kono
parents:
diff changeset
1169
kono
parents:
diff changeset
1170 Sat Aug 3 01:27:41 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1171
kono
parents:
diff changeset
1172 * cvt.c (add_builtin_candidates): Do consider type conversion ops
kono
parents:
diff changeset
1173 for the first parms of += et al.
kono
parents:
diff changeset
1174 (strip_top_quals): New fn.
kono
parents:
diff changeset
1175 (reference_binding): Use it instead of TYPE_MAIN_VARIANT.
kono
parents:
diff changeset
1176 (implicit_conversion): Likewise.
kono
parents:
diff changeset
1177 (add_builtin_candidates): Be careful about arrays.
kono
parents:
diff changeset
1178 (build_new_method_call): Handle vtable optimization.
kono
parents:
diff changeset
1179
kono
parents:
diff changeset
1180 Fri Aug 2 01:26:59 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1181
kono
parents:
diff changeset
1182 * cp-tree.h (LOOKUP_NO_TEMP_BIND): New flag.
kono
parents:
diff changeset
1183 * cvt.c (reference_binding): Use it.
kono
parents:
diff changeset
1184 (implicit_conversion): Use it.
kono
parents:
diff changeset
1185 (add_builtin_candidate, COND_EXPR): Use it.
kono
parents:
diff changeset
1186
kono
parents:
diff changeset
1187 * cvt.c (build_new_function_call): Check for error args.
kono
parents:
diff changeset
1188
kono
parents:
diff changeset
1189 * typeck.c (comptypes): Just check DERIVED_FROM_P, not UNIQUELY.
kono
parents:
diff changeset
1190
kono
parents:
diff changeset
1191 * gxx.gperf: Add __null.
kono
parents:
diff changeset
1192 * hash.h: Regenerate.
kono
parents:
diff changeset
1193 * lex.h: Add RID_NULL.
kono
parents:
diff changeset
1194 * lex.c (init_lex): Create null_pointer_node here, stick it in
kono
parents:
diff changeset
1195 RID_NULL.
kono
parents:
diff changeset
1196 * decl.c (init_decl_processing): Still set its type here.
kono
parents:
diff changeset
1197 * cvt.c (cp_convert_to_pointer): Don't produce null_pointer_node.
kono
parents:
diff changeset
1198 (convert_to_pointer_force): Likewise.
kono
parents:
diff changeset
1199 (null_ptr_cst_p): Check for null_pointer_node; only accept (void*)0
kono
parents:
diff changeset
1200 if (! pedantic).
kono
parents:
diff changeset
1201 * call.c (convert_harshness): Use null_ptr_cst_p.
kono
parents:
diff changeset
1202 * typeck.c (convert_for_assignment): Likewise. Don't produce
kono
parents:
diff changeset
1203 null_pointer_node.
kono
parents:
diff changeset
1204
kono
parents:
diff changeset
1205 * error.c (args_as_string): Handle lists of actual args, too.
kono
parents:
diff changeset
1206 * cvt.c (null_ptr_cst): Support (void*)0 for now.
kono
parents:
diff changeset
1207 (build_user_type_conversion_1): Improve diagnostics.
kono
parents:
diff changeset
1208 (build_new_function_call): Likewise.
kono
parents:
diff changeset
1209 (build_object_call): Likewise.
kono
parents:
diff changeset
1210 (build_new_method_call): Likewise. Move call before def diagnostic...
kono
parents:
diff changeset
1211 (build_over_call): Here.
kono
parents:
diff changeset
1212
kono
parents:
diff changeset
1213 * cvt.c (build_new_method_call): Don't complain about no match if
kono
parents:
diff changeset
1214 LOOKUP_SPECULATIVELY.
kono
parents:
diff changeset
1215 (build_over_call): Fix 'this' for virtual fn.
kono
parents:
diff changeset
1216 (build_new_method_call): Add diagnostic.
kono
parents:
diff changeset
1217
kono
parents:
diff changeset
1218 Thu Aug 1 16:45:09 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1219
kono
parents:
diff changeset
1220 * cvt.c (add_function_candidate): Expect 'this' and 'in_chrg' for
kono
parents:
diff changeset
1221 constructors to be passed in.
kono
parents:
diff changeset
1222 (build_over_call): Likewise.
kono
parents:
diff changeset
1223 (build_user_type_conversion_1): Pass them in.
kono
parents:
diff changeset
1224 (convert_like): Likewise.
kono
parents:
diff changeset
1225 (build_object_call): Handle overloaded conversions.
kono
parents:
diff changeset
1226 (build_over_call): Pass the right args to build_vfn_ref.
kono
parents:
diff changeset
1227 (standard_conversion): Fix pmf convs.
kono
parents:
diff changeset
1228 (joust): Handle comparing statics and non-statics.
kono
parents:
diff changeset
1229 (build_new_method_call): New fn.
kono
parents:
diff changeset
1230 * call.c (build_method_call): Call it if NEW_OVER.
kono
parents:
diff changeset
1231
kono
parents:
diff changeset
1232 Thu Aug 1 16:06:14 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1233
kono
parents:
diff changeset
1234 * lex.c (do_identifier): Don't use %O on IDENTIFIER_OPNAME_Ps, use
kono
parents:
diff changeset
1235 %D instead.
kono
parents:
diff changeset
1236
kono
parents:
diff changeset
1237 Thu Aug 1 15:24:02 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1238
kono
parents:
diff changeset
1239 * except.c (expand_throw): Use maybe_build_cleanup_and_delete
kono
parents:
diff changeset
1240 instead of just maybe_build_cleanup so that we deallocate the
kono
parents:
diff changeset
1241 thrown object.
kono
parents:
diff changeset
1242
kono
parents:
diff changeset
1243 Thu Aug 1 15:18:00 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1244
kono
parents:
diff changeset
1245 * decl2.c (finish_prevtable_vardecl): Make non-static for pt.c's use.
kono
parents:
diff changeset
1246 * cp-tree.h (finish_prevtable_vardecl): Add decl.
kono
parents:
diff changeset
1247
kono
parents:
diff changeset
1248 Thu Aug 1 11:53:51 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1249
kono
parents:
diff changeset
1250 * pt.c (instantiate_class_template): Call complete_type. Also, if
kono
parents:
diff changeset
1251 we're at the end of the file and we just instantiated a template
kono
parents:
diff changeset
1252 class with a vtable, call finish_prevtable_vardecl.
kono
parents:
diff changeset
1253
kono
parents:
diff changeset
1254 * error.c (dump_decl): Don't explode (or explode more gracefully
kono
parents:
diff changeset
1255 as appropriate) if the object being dumped has a null type.
kono
parents:
diff changeset
1256 (dump_expr): Likewise.
kono
parents:
diff changeset
1257
kono
parents:
diff changeset
1258 * search.c (build_mi_matrix): Ensure that mi_size is large enough,
kono
parents:
diff changeset
1259 by counting the number of nodes that we'll need before allocating
kono
parents:
diff changeset
1260 the array.
kono
parents:
diff changeset
1261 (lookup_fnfields): Fix comment.
kono
parents:
diff changeset
1262 (breadth_first_search): Fix comment.
kono
parents:
diff changeset
1263
kono
parents:
diff changeset
1264 Wed Jul 31 09:57:05 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1265
kono
parents:
diff changeset
1266 * pt.c (instantiate_class_template): Propagate TYPE_PACKED and
kono
parents:
diff changeset
1267 TYPE_ALIGN.
kono
parents:
diff changeset
1268 * class.c (finish_struct): Call cplus_decl_attributes here.
kono
parents:
diff changeset
1269 (finish_struct_1): Not here.
kono
parents:
diff changeset
1270 * cp-tree.h: Adjust.
kono
parents:
diff changeset
1271
kono
parents:
diff changeset
1272 * pt.c (type_unification): New parameter STRICT.
kono
parents:
diff changeset
1273 (unify): If STRICT, don't allow cv addition or base deduction.
kono
parents:
diff changeset
1274 * call.c, class.c, cvt.c, cp-tree.h: Adjust.
kono
parents:
diff changeset
1275
kono
parents:
diff changeset
1276 Tue Jul 30 13:06:13 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1277
kono
parents:
diff changeset
1278 * search.c (get_template_base{_recursive}): New fns.
kono
parents:
diff changeset
1279 * pt.c (more_specialized): New fn.
kono
parents:
diff changeset
1280 (do_function_instantiation): Use it.
kono
parents:
diff changeset
1281 (unify): Handle base deduction.
kono
parents:
diff changeset
1282 * cvt.c (joust): Use more_specialized.
kono
parents:
diff changeset
1283 Don't arbitrarily choose between non-builtin candidates.
kono
parents:
diff changeset
1284 (build_over_call): Call require_complete_type.
kono
parents:
diff changeset
1285
kono
parents:
diff changeset
1286 * decl.c (start_function): Statics are static even in a #pragma
kono
parents:
diff changeset
1287 interface file.
kono
parents:
diff changeset
1288
kono
parents:
diff changeset
1289 * decl2.c (import_export_vtable): Disable vtable heuristic on
kono
parents:
diff changeset
1290 systems with ASM_OUTPUT_EXTERNAL.
kono
parents:
diff changeset
1291
kono
parents:
diff changeset
1292 * cvt.c (compare_ics): Fix comparison of PMEM_CONV and BASE_CONV.
kono
parents:
diff changeset
1293 (standard_conversion): No std conv to enum type.
kono
parents:
diff changeset
1294
kono
parents:
diff changeset
1295 * cvt.c (standard_conversion): Fix order of args to DERIVED_FROM_P
kono
parents:
diff changeset
1296 for ptm's.
kono
parents:
diff changeset
1297
kono
parents:
diff changeset
1298 * cvt.c (reference_binding): Bind directly to a base subobject of
kono
parents:
diff changeset
1299 a class rvalue.
kono
parents:
diff changeset
1300
kono
parents:
diff changeset
1301 * cvt.c (build_new_op): Enforce access control.
kono
parents:
diff changeset
1302
kono
parents:
diff changeset
1303 Tue Jul 30 09:22:53 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1304
kono
parents:
diff changeset
1305 * typeck2.c (process_init_constructor): When scanning the
kono
parents:
diff changeset
1306 union for a named field, skip things that aren't FIELD_DECLs.
kono
parents:
diff changeset
1307
kono
parents:
diff changeset
1308 * method.c (synthesize_method): Don't scan fndecl's rtl if
kono
parents:
diff changeset
1309 we're at the end of the file; just assume the function can't
kono
parents:
diff changeset
1310 be inlined.
kono
parents:
diff changeset
1311
kono
parents:
diff changeset
1312 Mon Jul 29 15:48:30 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1313
kono
parents:
diff changeset
1314 * cvt.c (build_builtin_candidate): Stick a dummy conversion in if
kono
parents:
diff changeset
1315 it failed.
kono
parents:
diff changeset
1316
kono
parents:
diff changeset
1317 * cvt.c (build_user_type_conversion_1): Handle overloaded
kono
parents:
diff changeset
1318 conversion ops.
kono
parents:
diff changeset
1319
kono
parents:
diff changeset
1320 * cvt.c (add_builtin_candidates): Don't consider type conversion
kono
parents:
diff changeset
1321 operators for the first parameter of operator=.
kono
parents:
diff changeset
1322
kono
parents:
diff changeset
1323 Mon Jul 29 15:33:55 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1324
kono
parents:
diff changeset
1325 * typeck.c (complete_type): Only call layout_type if we're not
kono
parents:
diff changeset
1326 expanding a template.
kono
parents:
diff changeset
1327
kono
parents:
diff changeset
1328 Mon Jul 29 14:40:38 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1329
kono
parents:
diff changeset
1330 * cvt.c (compare_ics): Oops.
kono
parents:
diff changeset
1331
kono
parents:
diff changeset
1332 * cvt.c (op_error): Oops.
kono
parents:
diff changeset
1333
kono
parents:
diff changeset
1334 * cp-tree.def: Add RVALUE_CONV, rename EXACT_CONV to IDENTITY_CONV.
kono
parents:
diff changeset
1335 * cvt.c: Add IDENTITY_RANK before others. Use real_lvalue_p.
kono
parents:
diff changeset
1336 (build_conv): Use them.
kono
parents:
diff changeset
1337 (implicit_conversion): Use them.
kono
parents:
diff changeset
1338 (convert_like): Handle them.
kono
parents:
diff changeset
1339 (build_new_op): Handle builtin COND_EXPR again.
kono
parents:
diff changeset
1340 (add_builtin_candidates): Strip cv-quals. Fix oops. Include enums
kono
parents:
diff changeset
1341 in lists of types for COND_EXPR.
kono
parents:
diff changeset
1342 (add_builtin_candidate): Add enum candidates for COND_EXPR.
kono
parents:
diff changeset
1343
kono
parents:
diff changeset
1344 Mon Jul 29 12:05:40 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1345
kono
parents:
diff changeset
1346 * typeck.c (build_modify_expr): Always attempt to build a call to
kono
parents:
diff changeset
1347 the assignment operator, even if we're using a default one.
kono
parents:
diff changeset
1348 (convert_for_initialization): Call complete_type.
kono
parents:
diff changeset
1349
kono
parents:
diff changeset
1350 Mon Jul 29 11:25:08 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1351
kono
parents:
diff changeset
1352 * cvt.c (reference_binding): A REF_BIND gets the reference type.
kono
parents:
diff changeset
1353 (implicit_conversion): Likewise.
kono
parents:
diff changeset
1354 (convert_like): Likewise.
kono
parents:
diff changeset
1355 (compare_ics): Likewise.
kono
parents:
diff changeset
1356 (compare_qual): Likewise.
kono
parents:
diff changeset
1357 (print_z_candidates): Handle no candidates.
kono
parents:
diff changeset
1358 (build_new_op): Don't handle builtin COND_EXPR for now.
kono
parents:
diff changeset
1359
kono
parents:
diff changeset
1360 Sat Jul 27 11:27:47 1996 Stan Shebs <shebs@andros.cygnus.com>
kono
parents:
diff changeset
1361
kono
parents:
diff changeset
1362 * cvt.c (build_builtin_candidate): Init local var in an ANSI way.
kono
parents:
diff changeset
1363
kono
parents:
diff changeset
1364 Fri Jul 26 01:07:22 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1365
kono
parents:
diff changeset
1366 * cvt.c (joust): If the candidates are the same, arbitrarily pick one.
kono
parents:
diff changeset
1367
kono
parents:
diff changeset
1368 * cvt.c (build_builtin_candidate): Oops.
kono
parents:
diff changeset
1369 (build_new_op): Oops.
kono
parents:
diff changeset
1370
kono
parents:
diff changeset
1371 * method.c (build_opfncall): Pass COND_EXPR on.
kono
parents:
diff changeset
1372 * cvt.c (build_builtin_candidate): Reorganize, support COND_EXPR.
kono
parents:
diff changeset
1373 (add_builtin_candidate{,s}): Likewise.
kono
parents:
diff changeset
1374 (add_builtin_candidates): Likewise.
kono
parents:
diff changeset
1375 (print_z_candidates, op_error, build_new_op): Likewise.
kono
parents:
diff changeset
1376 (type_decays_to): New fn.
kono
parents:
diff changeset
1377 * lex.c (init_lex): Just say ?: for COND_EXPR.
kono
parents:
diff changeset
1378
kono
parents:
diff changeset
1379 Thu Jul 25 09:33:33 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1380
kono
parents:
diff changeset
1381 * typeck.c (complete_type): Call layout_type rather than building
kono
parents:
diff changeset
1382 a new array type.
kono
parents:
diff changeset
1383
kono
parents:
diff changeset
1384 * cvt.c (add_builtin_candidate): Pointer arithmetic candidates
kono
parents:
diff changeset
1385 only use ptrdiff_t.
kono
parents:
diff changeset
1386
kono
parents:
diff changeset
1387 Wed Jul 24 12:45:08 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1388
kono
parents:
diff changeset
1389 * cvt.c: Always compile the new overloading code (but don't use it).
kono
parents:
diff changeset
1390 (implicit_conversion): Add a BASE_CONV when converting to
kono
parents:
diff changeset
1391 the same class type.
kono
parents:
diff changeset
1392 (convert_like): Handle BASE_CONV.
kono
parents:
diff changeset
1393
kono
parents:
diff changeset
1394 Tue Jul 23 12:46:30 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1395
kono
parents:
diff changeset
1396 * cvt.c (build_new_op): Support {MAX,MIN}_EXPR.
kono
parents:
diff changeset
1397 (add_builtin_candidate): Likewise.
kono
parents:
diff changeset
1398
kono
parents:
diff changeset
1399 NEW_OVER changes:
kono
parents:
diff changeset
1400 * typeck.c (build_x_function_call): Try an operator function
kono
parents:
diff changeset
1401 whenever we call an object of class type.
kono
parents:
diff changeset
1402 * method.c (build_opfncall): Pass CALL_EXPRs through.
kono
parents:
diff changeset
1403 * cvt.c (implicit_conversion): Do const-ref case first.
kono
parents:
diff changeset
1404 (add_conv_candidate, build_object_call, op_error): New fns.
kono
parents:
diff changeset
1405 (ptr_complete_ob, TYPE_PTROB_P): void is not an object type.
kono
parents:
diff changeset
1406 ({add,build}_builtin_candidate{,s}, print_z_candidates): Display
kono
parents:
diff changeset
1407 builtin candidates.
kono
parents:
diff changeset
1408 (build_new_op): Handle CALL_EXPR. Don't try to decay void.
kono
parents:
diff changeset
1409 Fall back on preincrement handling. Use op_error.
kono
parents:
diff changeset
1410 Handle warn_synth.
kono
parents:
diff changeset
1411 (convert_like): Pass INDIRECT_BIND. Don't try to do anything with
kono
parents:
diff changeset
1412 an error_mark_node.
kono
parents:
diff changeset
1413 (build_over_call): Handle PROMOTE_PROTOTYPES and ellipsis promotions
kono
parents:
diff changeset
1414 properly.
kono
parents:
diff changeset
1415
kono
parents:
diff changeset
1416 Mon Jul 22 16:21:55 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1417
kono
parents:
diff changeset
1418 * pt.c (tsubst_expr): Handle CONTINUE_STMT.
kono
parents:
diff changeset
1419
kono
parents:
diff changeset
1420 Mon Jul 22 15:38:58 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1421
kono
parents:
diff changeset
1422 * typeck.c (build_component_ref_1): Use build_component_ref
kono
parents:
diff changeset
1423 instead of open coding it here.
kono
parents:
diff changeset
1424
kono
parents:
diff changeset
1425 Mon Jul 22 12:18:54 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1426
kono
parents:
diff changeset
1427 * g++.c (main): Don't link with -lg++.
kono
parents:
diff changeset
1428
kono
parents:
diff changeset
1429 NEW_OVER changes:
kono
parents:
diff changeset
1430 * cvt.c (convert_to_reference): Don't use convert_from_reference on
kono
parents:
diff changeset
1431 result of build_type_conversion.
kono
parents:
diff changeset
1432 (cp_convert): Only call build_method_call for ctors if
kono
parents:
diff changeset
1433 build_type_conversion failed.
kono
parents:
diff changeset
1434 (ptr_complete_ob): New function.
kono
parents:
diff changeset
1435 (TYPE_PTR{,OB,MEM}_P): New macros.
kono
parents:
diff changeset
1436 ({add,build}_builtin_candidate{,s}): New functions.
kono
parents:
diff changeset
1437 (print_z_candidates): Handle builtins.
kono
parents:
diff changeset
1438 (build_user_type_conversion_1): Don't use conversion fns for
kono
parents:
diff changeset
1439 converting to a base type.
kono
parents:
diff changeset
1440 (build_user_type_conversion_1): Set ICS_USER_FLAG on AMBIG_CONVs.
kono
parents:
diff changeset
1441 (build_user_type_conversion): Use convert_from_reference.
kono
parents:
diff changeset
1442 (build_new_op): New function.
kono
parents:
diff changeset
1443 (build_over_call): Fix handling of methods.
kono
parents:
diff changeset
1444 (compare_ics): Handle AMBIG_CONV properly.
kono
parents:
diff changeset
1445 * typeck2.c: Increment abort count.
kono
parents:
diff changeset
1446 * method.c (build_opfncall): Forward most requests to build_new_op.
kono
parents:
diff changeset
1447 * cp-tree.h (IS_OVERLOAD_TYPE): Tweak.
kono
parents:
diff changeset
1448
kono
parents:
diff changeset
1449 Fri Jul 19 17:59:29 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1450
kono
parents:
diff changeset
1451 * error.c (dump_expr, case CONSTRUCTOR, case CAST_EXPR): Take out
kono
parents:
diff changeset
1452 invalid second argument to dump_expr_list.
kono
parents:
diff changeset
1453
kono
parents:
diff changeset
1454 Fri Jul 19 14:04:05 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1455
kono
parents:
diff changeset
1456 * decl.c (lookup_name_real): Make sure we do obj->X::i correctly.
kono
parents:
diff changeset
1457
kono
parents:
diff changeset
1458 Thu Jul 18 14:48:23 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1459
kono
parents:
diff changeset
1460 * decl2.c (import_export_vtable): ASM_OUTPUT_EXTERNAL, not
kono
parents:
diff changeset
1461 ASSEMBLE_EXTERNAL.
kono
parents:
diff changeset
1462
kono
parents:
diff changeset
1463 Mon Jul 15 17:48:43 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1464
kono
parents:
diff changeset
1465 * typeck2.c (process_init_constructor): New pedwarn for using { }
kono
parents:
diff changeset
1466 to initialize a pointer to member function.
kono
parents:
diff changeset
1467 * typeck.c (build_ptrmemfunc1): Avoid use of digest_init so that
kono
parents:
diff changeset
1468 we can avoid the new error.
kono
parents:
diff changeset
1469
kono
parents:
diff changeset
1470 Mon Jul 15 15:42:03 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1471
kono
parents:
diff changeset
1472 * typeck.c (build_ptrmemfunc1): New function to hide details of
kono
parents:
diff changeset
1473 pointer to member functions better.
kono
parents:
diff changeset
1474
kono
parents:
diff changeset
1475 Mon Jul 15 14:23:02 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1476
kono
parents:
diff changeset
1477 * init.c (resolve_offset_ref): Resolve OFFSET_REFs that are
kono
parents:
diff changeset
1478 methods into the actual method, as we know the implied object is
kono
parents:
diff changeset
1479 not used.
kono
parents:
diff changeset
1480
kono
parents:
diff changeset
1481 Mon Jul 15 13:08:29 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1482
kono
parents:
diff changeset
1483 * parse.y (maybecomma_warn): Only emit the pedwarn if we're not
kono
parents:
diff changeset
1484 inside a system header.
kono
parents:
diff changeset
1485
kono
parents:
diff changeset
1486 Fri Jul 12 16:30:05 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1487
kono
parents:
diff changeset
1488 * call.c (build_method_call): Call complete_type on the
kono
parents:
diff changeset
1489 instance type.
kono
parents:
diff changeset
1490
kono
parents:
diff changeset
1491 Thu Jul 11 17:16:40 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1492
kono
parents:
diff changeset
1493 * typeck.c (build_component_ref): Always build up an OFFSET_REF
kono
parents:
diff changeset
1494 for obj_ptr->func so that we can know which object to use in a
kono
parents:
diff changeset
1495 method call.
kono
parents:
diff changeset
1496
kono
parents:
diff changeset
1497 Wed Jul 10 19:36:37 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1498
kono
parents:
diff changeset
1499 * typeck.c (build_ptrmemfunc): Remove sorry, now we can cast
kono
parents:
diff changeset
1500 around things. Also improve maintainability.
kono
parents:
diff changeset
1501
kono
parents:
diff changeset
1502 Wed Jul 10 18:20:11 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1503
kono
parents:
diff changeset
1504 * decl.c (grokdeclarator): Check for overflow when evaluating an
kono
parents:
diff changeset
1505 array dimension.
kono
parents:
diff changeset
1506
kono
parents:
diff changeset
1507 Wed Jul 10 17:26:19 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1508
kono
parents:
diff changeset
1509 * cvt.c (cp_convert): Don't check for ambiguity with constructor
kono
parents:
diff changeset
1510 if NEW_OVER.
kono
parents:
diff changeset
1511
kono
parents:
diff changeset
1512 * typeck.c (build_x_function_call): Pass function overload
kono
parents:
diff changeset
1513 questions to new overloading code if NEW_OVER.
kono
parents:
diff changeset
1514 * init.c (expand_aggr_init_1): Only check for type conversion ops
kono
parents:
diff changeset
1515 if we're doing copy-initialization (i.e. LOOKUP_ONLYCONVERTING).
kono
parents:
diff changeset
1516 Don't check for ambiguity with constructor if NEW_OVER.
kono
parents:
diff changeset
1517 * cvt.c (convert_to_reference): Dereference the result of a type
kono
parents:
diff changeset
1518 conversion operator.
kono
parents:
diff changeset
1519 (build_conv): Propagate ICS_USER_FLAG.
kono
parents:
diff changeset
1520 (implicit_conversion): Call instantiate_type.
kono
parents:
diff changeset
1521 Pass LOOKUP_ONLYCONVERTING instead of LOOKUP_NORMAL.
kono
parents:
diff changeset
1522 (add_function_candidate): Fix cv-quals on argtype.
kono
parents:
diff changeset
1523 (print_z_candidates): New function.
kono
parents:
diff changeset
1524 (build_new_function_call): Call it.
kono
parents:
diff changeset
1525 (build_user_type_conversion_1): If LOOKUP_ONLYCONVERTING, don't
kono
parents:
diff changeset
1526 consider non-converting constructors.
kono
parents:
diff changeset
1527 Call print_z_candidates.
kono
parents:
diff changeset
1528 Return an AMBIG_CONV for an ambiguous conversion.
kono
parents:
diff changeset
1529 (build_user_type_conversion): Handle AMBIG_CONV.
kono
parents:
diff changeset
1530 (convert_like): Fix test for building TARGET_EXPR.
kono
parents:
diff changeset
1531 Call instantiate_type.
kono
parents:
diff changeset
1532 Handle AMBIG_CONV and LVALUE_CONV.
kono
parents:
diff changeset
1533 (build_over_call): Handle 0 args and ellipsis.
kono
parents:
diff changeset
1534 * cp-tree.def: Add AMBIG_CONV.
kono
parents:
diff changeset
1535
kono
parents:
diff changeset
1536 Tue Jul 9 17:48:48 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1537
kono
parents:
diff changeset
1538 * decl.c (lookup_name_real): If we find mem in obj when parsing
kono
parents:
diff changeset
1539 `obj->mem', make sure we return the right value.
kono
parents:
diff changeset
1540
kono
parents:
diff changeset
1541 Tue Jul 9 16:11:28 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1542
kono
parents:
diff changeset
1543 * search.c (get_base_distance): Call complete_type.
kono
parents:
diff changeset
1544
kono
parents:
diff changeset
1545 Tue Jul 9 12:46:34 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1546
kono
parents:
diff changeset
1547 * decl.c (store_bindings): Make static.
kono
parents:
diff changeset
1548
kono
parents:
diff changeset
1549 Mon Jul 8 16:42:31 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1550
kono
parents:
diff changeset
1551 * init.c (expand_aggr_init_1): Don't check type conversions if
kono
parents:
diff changeset
1552 NEW_OVER.
kono
parents:
diff changeset
1553
kono
parents:
diff changeset
1554 * cvt.c (z_candidate): Put back template field.
kono
parents:
diff changeset
1555 (add_function_candidate): Set it.
kono
parents:
diff changeset
1556 (add_template_candidate): Likewise.
kono
parents:
diff changeset
1557 (joust): Use it.
kono
parents:
diff changeset
1558 (compare_qual): Handle references and pointers to members.
kono
parents:
diff changeset
1559 (compare_ics): Handle reference bindings.
kono
parents:
diff changeset
1560
kono
parents:
diff changeset
1561 * decl.c (duplicate_decls): Propagate DECL_ONE_ONLY.
kono
parents:
diff changeset
1562
kono
parents:
diff changeset
1563 Mon Jul 8 16:18:56 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1564
kono
parents:
diff changeset
1565 * call.c (compute_conversion_costs): Call complete_type.
kono
parents:
diff changeset
1566
kono
parents:
diff changeset
1567 * tree.c (vec_binfo_member): Use comptypes instead of comparing
kono
parents:
diff changeset
1568 pointers, so we can handle template parameters.
kono
parents:
diff changeset
1569
kono
parents:
diff changeset
1570 Fri Jul 5 16:51:53 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1571
kono
parents:
diff changeset
1572 * cvt.c (cp_convert_to_pointer): We have to call complete_type
kono
parents:
diff changeset
1573 here; let's make it explicit instead of a side effect of an
kono
parents:
diff changeset
1574 error check.
kono
parents:
diff changeset
1575
kono
parents:
diff changeset
1576 Wed Jul 3 16:29:51 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1577
kono
parents:
diff changeset
1578 * cvt.c (z_candidate): Remove template field.
kono
parents:
diff changeset
1579 (reference_binding): Handle binding to temporary.
kono
parents:
diff changeset
1580 (implicit_conversion): Likewise.
kono
parents:
diff changeset
1581 (add_function_candidate): Handle artificial constructor parms.
kono
parents:
diff changeset
1582 Handle functions with too few parms.
kono
parents:
diff changeset
1583 (add_template_candidate): New function.
kono
parents:
diff changeset
1584 (build_user_type_conversion_1): Handle constructors.
kono
parents:
diff changeset
1585 (convert_like): Likewise.
kono
parents:
diff changeset
1586 (build_over_call): Likewise.
kono
parents:
diff changeset
1587 (build_new_function_call): Support templates.
kono
parents:
diff changeset
1588 (compare_ics): Fix reference, inheritance handling.
kono
parents:
diff changeset
1589
kono
parents:
diff changeset
1590 Mon Jul 1 22:58:18 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1591
kono
parents:
diff changeset
1592 * decl.c: Add signed_size_zero_node.
kono
parents:
diff changeset
1593 (init_decl_processing): Build it.
kono
parents:
diff changeset
1594 * class.c (prepare_fresh_vtable): Use it instead of size_zero_node
kono
parents:
diff changeset
1595 when we're trying to make a negative delta.
kono
parents:
diff changeset
1596
kono
parents:
diff changeset
1597 Mon Jul 1 17:56:19 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1598
kono
parents:
diff changeset
1599 Stop doing this damn index==strchr variable name confusion.
kono
parents:
diff changeset
1600 * class.c (add_virtual_function): Change local var INDEX to be
kono
parents:
diff changeset
1601 named IDX.
kono
parents:
diff changeset
1602 (add_method): Likewise.
kono
parents:
diff changeset
1603 * lex.c (print_parse_statistics): Likewise.
kono
parents:
diff changeset
1604 * search.c (make_memoized_table_entry): Likewise.
kono
parents:
diff changeset
1605 (lookup_fnfields_here): Likewise.
kono
parents:
diff changeset
1606 (lookup_field): Likewise.
kono
parents:
diff changeset
1607 (lookup_fnfields): Likewise.
kono
parents:
diff changeset
1608 (get_baselinks): Likewise.
kono
parents:
diff changeset
1609 * sig.c (build_signature_table_constructor): Likewise.
kono
parents:
diff changeset
1610 (build_signature_method_call): Likewise.
kono
parents:
diff changeset
1611 * typeck.c (build_x_array_ref): Change INDEX parm to be named IDX.
kono
parents:
diff changeset
1612 (get_member_function_from_ptrfunc): Likewise.
kono
parents:
diff changeset
1613 (build_ptrmemfunc): Change local var INDEX to be IDX.
kono
parents:
diff changeset
1614 (c_expand_start_case): Likewise.
kono
parents:
diff changeset
1615
kono
parents:
diff changeset
1616 Sat Jun 29 14:05:46 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1617
kono
parents:
diff changeset
1618 * cvt.c (cp_convert_to_pointer): Move user-defined type conversion
kono
parents:
diff changeset
1619 handling to before extraction of TYPE_PTRMEMFUNC_FN_TYPE.
kono
parents:
diff changeset
1620 (convert_to_reference): Use build_type_conversion to convert to
kono
parents:
diff changeset
1621 the reference type directly.
kono
parents:
diff changeset
1622 (standard_conversion): Fix void* case, non-conversions.
kono
parents:
diff changeset
1623 (reference_binding): Fix expr == 0 case, non-conversions.
kono
parents:
diff changeset
1624 (convert_like): Support REF_BIND.
kono
parents:
diff changeset
1625 (compare_qual): Split out from compare_ics.
kono
parents:
diff changeset
1626 (compare_ics): Use it, handle icses with only a qual_conv.
kono
parents:
diff changeset
1627
kono
parents:
diff changeset
1628 * init.c (expand_vec_init): Don't crash if decl is NULL.
kono
parents:
diff changeset
1629
kono
parents:
diff changeset
1630 Fri Jun 28 11:52:51 1996 Stan Shebs <shebs@andros.cygnus.com>
kono
parents:
diff changeset
1631
kono
parents:
diff changeset
1632 * mpw-config.in: New file, configury for Mac MPW.
kono
parents:
diff changeset
1633 * mpw-make.sed: New file, makefile editing for MPW.
kono
parents:
diff changeset
1634
kono
parents:
diff changeset
1635 Thu Jun 27 15:18:30 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1636
kono
parents:
diff changeset
1637 * pt.c (instantiate_class_template): Call repo_template_used.
kono
parents:
diff changeset
1638
kono
parents:
diff changeset
1639 * search.c (lookup_conversions): Only lookup conversions in
kono
parents:
diff changeset
1640 complete types.
kono
parents:
diff changeset
1641
kono
parents:
diff changeset
1642 Thu Jun 27 12:59:53 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1643
kono
parents:
diff changeset
1644 * cp-tree.def: Renamed from tree.def, to avoid confusion with
kono
parents:
diff changeset
1645 gcc's tree.def.
kono
parents:
diff changeset
1646 * cp-tree.h, lex.c: Include cp-tree.def.
kono
parents:
diff changeset
1647 * Makefile.in (CXX_TREE_H): Reference cp-tree.def.
kono
parents:
diff changeset
1648
kono
parents:
diff changeset
1649 Wed Jun 26 18:29:47 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1650
kono
parents:
diff changeset
1651 * init.c (build_vec_delete_1): Call complete_type.
kono
parents:
diff changeset
1652
kono
parents:
diff changeset
1653 Mon Jun 24 17:17:32 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1654
kono
parents:
diff changeset
1655 * except.c (start_anon_func): Make sure anonymous functions are
kono
parents:
diff changeset
1656 never external.
kono
parents:
diff changeset
1657
kono
parents:
diff changeset
1658 Fri Jun 21 15:10:58 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1659
kono
parents:
diff changeset
1660 * decl.c (finish_function): If function_depth > 1, set nested.
kono
parents:
diff changeset
1661
kono
parents:
diff changeset
1662 * decl2.c (grokbitfield): Revert Bob's change.
kono
parents:
diff changeset
1663 * class.c (finish_struct_1): Fix handling of named bitfield widths.
kono
parents:
diff changeset
1664
kono
parents:
diff changeset
1665 Thu Jun 20 23:35:38 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1666
kono
parents:
diff changeset
1667 * pt.c (add_pending_template): Handle types.
kono
parents:
diff changeset
1668 (lookup_template_class): With -fexternal-templates, just add the class
kono
parents:
diff changeset
1669 to pending_templates instead of instantiating it now.
kono
parents:
diff changeset
1670 * decl2.c (finish_file): Handle types in pending_templates.
kono
parents:
diff changeset
1671
kono
parents:
diff changeset
1672 Thu Jun 20 14:08:40 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1673
kono
parents:
diff changeset
1674 * decl2.c (grokbitfield): Handle constant decls appropriately.
kono
parents:
diff changeset
1675 Give an appropriate error message now instead of spewing core
kono
parents:
diff changeset
1676 later.
kono
parents:
diff changeset
1677
kono
parents:
diff changeset
1678 Thu Jun 20 13:01:51 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1679
kono
parents:
diff changeset
1680 * decl2.c: Don't turn on thunks by default for now.
kono
parents:
diff changeset
1681
kono
parents:
diff changeset
1682 Wed Jun 19 11:37:04 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1683
kono
parents:
diff changeset
1684 * typeck.c (complete_type): Handle error_mark_node.
kono
parents:
diff changeset
1685 (common_type, OFFSET_TYPE): Handle template_type_parms.
kono
parents:
diff changeset
1686
kono
parents:
diff changeset
1687 Tue Jun 18 10:02:15 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1688
kono
parents:
diff changeset
1689 * pt.c (instantiate_decl): If at_eof, call import_export_decl
kono
parents:
diff changeset
1690 regardless of DECL_INLINE.
kono
parents:
diff changeset
1691
kono
parents:
diff changeset
1692 * typeck.c (mark_addressable): Set TREE_ADDRESSABLE on CONSTRUCTORs.
kono
parents:
diff changeset
1693
kono
parents:
diff changeset
1694 * class.c (finish_struct_bits): Copy TYPE_SIZE.
kono
parents:
diff changeset
1695
kono
parents:
diff changeset
1696 * rtti.c (build_dynamic_cast): Support templates.
kono
parents:
diff changeset
1697 * tree.def: Support DYNAMIC_CAST_EXPR.
kono
parents:
diff changeset
1698 * pt.c (tsubst_copy): Likewise.
kono
parents:
diff changeset
1699 * decl2.c (build_expr_from_tree): Likewise.
kono
parents:
diff changeset
1700
kono
parents:
diff changeset
1701 Mon Jun 17 15:23:36 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1702
kono
parents:
diff changeset
1703 * typeck.c (build_static_cast): Support templates.
kono
parents:
diff changeset
1704 (build_const_cast): Likewise.
kono
parents:
diff changeset
1705 * tree.def: Support CONST/STATIC_CAST_EXPR.
kono
parents:
diff changeset
1706 * pt.c (tsubst_copy): Likewise.
kono
parents:
diff changeset
1707 * decl2.c (build_expr_from_tree): Likewise.
kono
parents:
diff changeset
1708
kono
parents:
diff changeset
1709 Sun Jun 16 12:33:57 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1710
kono
parents:
diff changeset
1711 * decl2.c (finish_vtable_vardecl): Don't trust
kono
parents:
diff changeset
1712 TREE_SYMBOL_REFERENCED for vtables of local classes.
kono
parents:
diff changeset
1713
kono
parents:
diff changeset
1714 Fri Jun 14 18:13:36 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1715
kono
parents:
diff changeset
1716 * pt.c (tsubst_copy): Handle operator T.
kono
parents:
diff changeset
1717
kono
parents:
diff changeset
1718 Wed Jun 12 17:52:40 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
1719
kono
parents:
diff changeset
1720 * init.c (build_delete): Move creation of PARMS inside test of
kono
parents:
diff changeset
1721 TYPE_HAS_DESTRUCTOR, since it's never used outside of that block.
kono
parents:
diff changeset
1722
kono
parents:
diff changeset
1723 Tue Jun 11 15:09:18 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1724
kono
parents:
diff changeset
1725 * typeck.c (build_conditional_expr): Don't assume that
kono
parents:
diff changeset
1726 the arguments to ?: are always pointers or records.
kono
parents:
diff changeset
1727
kono
parents:
diff changeset
1728 Tue Jun 11 13:56:23 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1729
kono
parents:
diff changeset
1730 * decl2.c (import_export_decl): Still emit static/weak/comdat
kono
parents:
diff changeset
1731 copies of inline template functions with -fno-implicit-templates.
kono
parents:
diff changeset
1732
kono
parents:
diff changeset
1733 Tue Jun 11 11:42:13 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1734
kono
parents:
diff changeset
1735 * init.c (build_delete): Determine the complete basetype
kono
parents:
diff changeset
1736 path to the destructor we're calling.
kono
parents:
diff changeset
1737
kono
parents:
diff changeset
1738 Fri Jun 7 15:30:10 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1739
kono
parents:
diff changeset
1740 * decl.c (build_enumerator): Always copy the INTEGER_CST used to
kono
parents:
diff changeset
1741 initialize the enum, because we really and truly don't know where
kono
parents:
diff changeset
1742 it came from.
kono
parents:
diff changeset
1743 (start_enum): Don't copy integer_zero_node because
kono
parents:
diff changeset
1744 build_enumerator will do it.
kono
parents:
diff changeset
1745
kono
parents:
diff changeset
1746 Fri Jun 7 11:11:09 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1747
kono
parents:
diff changeset
1748 * decl.c (finish_function): Do access control on base destructors.
kono
parents:
diff changeset
1749
kono
parents:
diff changeset
1750 * pt.c (tsubst, case FUNCTION_DECL): Set up
kono
parents:
diff changeset
1751 IDENTIFIER_GLOBAL_VALUE for member functions so pushdecl doesn't
kono
parents:
diff changeset
1752 hose us.
kono
parents:
diff changeset
1753
kono
parents:
diff changeset
1754 Fri Jun 7 10:37:33 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1755
kono
parents:
diff changeset
1756 * cvt.c (build_up_reference): If we have already extended the
kono
parents:
diff changeset
1757 lifetime of the temporary, don't try it again.
kono
parents:
diff changeset
1758 * typeck.c (c_expand_return): Don't try and convert the return
kono
parents:
diff changeset
1759 value twice when we want a reference, once is enough.
kono
parents:
diff changeset
1760
kono
parents:
diff changeset
1761 Tue Jun 4 15:41:45 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1762
kono
parents:
diff changeset
1763 * pt.c (tsubst_expr, case DECL_STMT): Don't pass
kono
parents:
diff changeset
1764 LOOKUP_ONLYCONVERTING at all for now.
kono
parents:
diff changeset
1765
kono
parents:
diff changeset
1766 * search.c (add_conversions): Put the conversion function in
kono
parents:
diff changeset
1767 TREE_VALUE, the basetype in TREE_PURPOSE.
kono
parents:
diff changeset
1768 * cvt.c (build_type_conversion): Adjust.
kono
parents:
diff changeset
1769 * cvt.c (build_expr_type_conversion): Adjust.
kono
parents:
diff changeset
1770 * call.c (user_harshness): Adjust.
kono
parents:
diff changeset
1771
kono
parents:
diff changeset
1772 Mon Jun 3 15:30:52 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1773
kono
parents:
diff changeset
1774 * method.c (emit_thunk): Pretend this is a FUNCTION_DECL for the
kono
parents:
diff changeset
1775 backend's benefit.
kono
parents:
diff changeset
1776
kono
parents:
diff changeset
1777 Mon Jun 10 18:58:19 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1778
kono
parents:
diff changeset
1779 * except.c (expand_start_catch_block): Add a dummy region, if we
kono
parents:
diff changeset
1780 get an error, so that we can avoid core dumping later.
kono
parents:
diff changeset
1781
kono
parents:
diff changeset
1782 Fri May 31 14:56:13 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1783
kono
parents:
diff changeset
1784 * cp-tree.h (OFFSET_REF): Remove.
kono
parents:
diff changeset
1785 * tree.def (CP_OFFSET_REF): Rename to OFFSET_REF.
kono
parents:
diff changeset
1786 * expr.c (cplus_expand_expr): Cleanup callers of expand_expr.
kono
parents:
diff changeset
1787 * init.c (expand_aggr_init_1): Likewise.
kono
parents:
diff changeset
1788 (build_new): Likewise.
kono
parents:
diff changeset
1789 * typeck.c (expand_target_expr): Likewise.
kono
parents:
diff changeset
1790
kono
parents:
diff changeset
1791 Fri May 31 14:22:08 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1792
kono
parents:
diff changeset
1793 * typeck.c (build_modify_expr): Don't use TREE_VALUE on a
kono
parents:
diff changeset
1794 TARGET_EXPR.
kono
parents:
diff changeset
1795
kono
parents:
diff changeset
1796 Wed May 29 17:04:33 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1797
kono
parents:
diff changeset
1798 * cvt.c (build_up_reference): Redo how and when temporaries are
kono
parents:
diff changeset
1799 created.
kono
parents:
diff changeset
1800 * decl.c (grok_reference_init): Don't try and be smart about
kono
parents:
diff changeset
1801 running cleanups.
kono
parents:
diff changeset
1802
kono
parents:
diff changeset
1803 Wed May 29 16:02:08 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1804
kono
parents:
diff changeset
1805 * cvt.c (build_up_reference): Add NULL_TREE to all calls to build
kono
parents:
diff changeset
1806 (TARGET_EXPR...), now that it has 4 arguments.
kono
parents:
diff changeset
1807 * tree.c (build_cplus_new): Likewise.
kono
parents:
diff changeset
1808
kono
parents:
diff changeset
1809 Thu May 23 16:40:30 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1810
kono
parents:
diff changeset
1811 * error.c (dump_expr, case CAST_EXPR): Handle T() properly.
kono
parents:
diff changeset
1812
kono
parents:
diff changeset
1813 * pt.c (instantiate_decl): Don't call push/pop_cp_function_context.
kono
parents:
diff changeset
1814 * decl.c (struct saved_scope): Remove named_labels,
kono
parents:
diff changeset
1815 {base,member}_init_list.
kono
parents:
diff changeset
1816 (maybe_push_to_top_level): Don't set them. Call
kono
parents:
diff changeset
1817 push_cp_function_context if appropriate.
kono
parents:
diff changeset
1818 (pop_from_top_level): Likewise.
kono
parents:
diff changeset
1819
kono
parents:
diff changeset
1820 * method.c (do_build_assign_ref): Remove obsolete check of
kono
parents:
diff changeset
1821 TYPE_HAS_ASSIGN_REF (basetype).
kono
parents:
diff changeset
1822
kono
parents:
diff changeset
1823 * decl.c (grokfndecl): Diagnose user definition of
kono
parents:
diff changeset
1824 implicitly-declared methods.
kono
parents:
diff changeset
1825
kono
parents:
diff changeset
1826 Thu May 23 12:13:08 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1827
kono
parents:
diff changeset
1828 * method.c (do_build_copy_constructor): Add code to give
kono
parents:
diff changeset
1829 meaningful error messages instead of crashing.
kono
parents:
diff changeset
1830 (do_build_assign_ref): Don't synthesize assignment operators for
kono
parents:
diff changeset
1831 classes containing reference or const members.
kono
parents:
diff changeset
1832
kono
parents:
diff changeset
1833 * class.c (struct base_info): Remove cant_synth_copy_ctor
kono
parents:
diff changeset
1834 and cant_synth_asn_ref.
kono
parents:
diff changeset
1835 (finish_base_struct): Remove the code that tries to conditionalize
kono
parents:
diff changeset
1836 synthesis of copy constructors & assignment operators based on
kono
parents:
diff changeset
1837 access permissions. Instead, let it fail when it tries to
kono
parents:
diff changeset
1838 synthesize the copy constructor. This will give meaningful error
kono
parents:
diff changeset
1839 messages instead of silently generating code to perform a bitcopy.
kono
parents:
diff changeset
1840
kono
parents:
diff changeset
1841 Wed May 22 11:45:19 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1842
kono
parents:
diff changeset
1843 * lex.c (real_yylex): Remove old-n-crufty #if 0 code for
kono
parents:
diff changeset
1844 determining types for constant values.
kono
parents:
diff changeset
1845
kono
parents:
diff changeset
1846 * decl.c (struct named_label_list): Use instead of stuffing
kono
parents:
diff changeset
1847 random items into a TREE_LIST node.
kono
parents:
diff changeset
1848 (named_label_uses): Use the new struct.
kono
parents:
diff changeset
1849 (poplevel): Likewise.
kono
parents:
diff changeset
1850 (lookup_label): Likewise.
kono
parents:
diff changeset
1851 (define_label): Add an error message to tell the user the line
kono
parents:
diff changeset
1852 where the goto is located in addition to the destination of the
kono
parents:
diff changeset
1853 goto.
kono
parents:
diff changeset
1854 (init_decl_processing): Use NULL instead of NULL_TREE to initialize
kono
parents:
diff changeset
1855 named_label_uses.
kono
parents:
diff changeset
1856 (finish_function): Likewise.
kono
parents:
diff changeset
1857
kono
parents:
diff changeset
1858 (start_decl): Complain about defining a static data member
kono
parents:
diff changeset
1859 in a different type from which it was declared.
kono
parents:
diff changeset
1860
kono
parents:
diff changeset
1861 Wed May 22 09:33:23 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1862
kono
parents:
diff changeset
1863 * cvt.c (build_expr_type_conversion): Adjust.
kono
parents:
diff changeset
1864
kono
parents:
diff changeset
1865 Tue May 21 11:21:56 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1866
kono
parents:
diff changeset
1867 * call.c (build_method_call): Always convert 'this' to the
kono
parents:
diff changeset
1868 appropriate type.
kono
parents:
diff changeset
1869
kono
parents:
diff changeset
1870 * search.c (add_conversions): Put the conversion function in
kono
parents:
diff changeset
1871 TREE_VALUE, the type in TREE_PURPOSE.
kono
parents:
diff changeset
1872 * cvt.c (build_type_conversion): Adjust.
kono
parents:
diff changeset
1873 * call.c (user_harshness): Adjust.
kono
parents:
diff changeset
1874
kono
parents:
diff changeset
1875 * method.c (emit_thunk): Call temporary_allocation and
kono
parents:
diff changeset
1876 permanent_allocation around the ASM_OUTPUT_MI_THUNK case, too.
kono
parents:
diff changeset
1877
kono
parents:
diff changeset
1878 * tree.c (build_cplus_array_type): Handle tweaking of
kono
parents:
diff changeset
1879 TYPE_MAIN_VARIANT here.
kono
parents:
diff changeset
1880 * typeck.c (common_type): Not here.
kono
parents:
diff changeset
1881
kono
parents:
diff changeset
1882 * typeck.c (complete_type): Only try to complete an array type if
kono
parents:
diff changeset
1883 it has a domain.
kono
parents:
diff changeset
1884
kono
parents:
diff changeset
1885 Mon May 20 14:55:59 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1886
kono
parents:
diff changeset
1887 * decl.c (grokvardecl): Call complete_type.
kono
parents:
diff changeset
1888 (grokdeclarator): Call complete_type for PARM_DECLs.
kono
parents:
diff changeset
1889
kono
parents:
diff changeset
1890 Fri May 17 16:41:17 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1891
kono
parents:
diff changeset
1892 * pt.c (instantiate_class_template): Re-set
kono
parents:
diff changeset
1893 CLASSTYPE_GOT_SEMICOLON after calling finish_struct_1.
kono
parents:
diff changeset
1894
kono
parents:
diff changeset
1895 Fri May 17 14:56:55 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1896
kono
parents:
diff changeset
1897 * cp-tree.h (cp_expand_decl_cleanup): Remove, the backend is now
kono
parents:
diff changeset
1898 smart enough to do it right.
kono
parents:
diff changeset
1899 * tree.c (cp_expand_decl_cleanup): Likewise.
kono
parents:
diff changeset
1900 * decl.c (cp_finish_decl): Use expand_decl_cleanup instead of
kono
parents:
diff changeset
1901 cp_expand_decl_cleanup.
kono
parents:
diff changeset
1902 (store_parm_decls): Likewise.
kono
parents:
diff changeset
1903 (hack_incomplete_structures): Likewise.
kono
parents:
diff changeset
1904 * except.c (push_eh_cleanup): Likewise.
kono
parents:
diff changeset
1905
kono
parents:
diff changeset
1906 Fri May 17 13:13:51 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1907
kono
parents:
diff changeset
1908 * expr.c (expand_expr, cond UNSAVE_EXPR): Move from the C++
kono
parents:
diff changeset
1909 frontend to the backend where it belongs.
kono
parents:
diff changeset
1910 * tree.c (unsave_expr): Likewise.
kono
parents:
diff changeset
1911 (unsave_expr_now): Likewise.
kono
parents:
diff changeset
1912 * tree.def (UNSAVE_EXPR): Likewise.
kono
parents:
diff changeset
1913 * cp-tree.h (unsave_expr): Likewise.
kono
parents:
diff changeset
1914 (unsave_expr_now): Likewise.
kono
parents:
diff changeset
1915
kono
parents:
diff changeset
1916 Fri May 17 11:02:41 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1917
kono
parents:
diff changeset
1918 * init.c (emit_base_init): Make sure the partial EH cleanups live
kono
parents:
diff changeset
1919 on the function_obstack.
kono
parents:
diff changeset
1920
kono
parents:
diff changeset
1921 Thu May 16 15:29:33 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
1922
kono
parents:
diff changeset
1923 * expr.c (do_case): Don't try to dereference null TREE_TYPEs
kono
parents:
diff changeset
1924 when checking for pointer types.
kono
parents:
diff changeset
1925
kono
parents:
diff changeset
1926 Thu May 16 13:38:58 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1927
kono
parents:
diff changeset
1928 * pt.c (instantiate_class_template): Remove obsolete check for
kono
parents:
diff changeset
1929 access declarations.
kono
parents:
diff changeset
1930
kono
parents:
diff changeset
1931 Thu May 16 13:34:15 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1932
kono
parents:
diff changeset
1933 * call.c (build_overload_call): Simplify calls to
kono
parents:
diff changeset
1934 build_overload_call by removing last parameter.
kono
parents:
diff changeset
1935 (build_method_call): Likewise.
kono
parents:
diff changeset
1936 * cp-tree.h: Likewise.
kono
parents:
diff changeset
1937 * method.c (build_opfncall): Likewise.
kono
parents:
diff changeset
1938 * typeck.c (build_x_function_call): Likewise.
kono
parents:
diff changeset
1939
kono
parents:
diff changeset
1940 Thu May 16 13:15:43 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1941
kono
parents:
diff changeset
1942 * call.c (default_parm_conversions): Factor out common code.
kono
parents:
diff changeset
1943 (build_method_call): Use it.
kono
parents:
diff changeset
1944 (build_overload_call_real): Use it.
kono
parents:
diff changeset
1945
kono
parents:
diff changeset
1946 Wed May 15 14:46:14 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1947
kono
parents:
diff changeset
1948 * call.c (build_method_call): Allow implicit & on METHOD_TYPEs,
kono
parents:
diff changeset
1949 but pedwarn as the code is bogus.
kono
parents:
diff changeset
1950 * typeck.c (decay_conversion): Likewise.
kono
parents:
diff changeset
1951 (build_function_call_real): Use build_addr_func instead of
kono
parents:
diff changeset
1952 default_conversion. Don't allow pointer-to-method functions down
kono
parents:
diff changeset
1953 here.
kono
parents:
diff changeset
1954 (build_unary_op): Use real pointer-to-member functions instead of
kono
parents:
diff changeset
1955 fake ones.
kono
parents:
diff changeset
1956 (build_ptrmemfunc): Use build_addr_func instead of build_unary_op.
kono
parents:
diff changeset
1957 (convert_for_assignment): Removed some obsolete code.
kono
parents:
diff changeset
1958 * decl2.c (reparse_absdcl_as_expr): Pass current_class_ref to
kono
parents:
diff changeset
1959 build_x_function_call instead of current_class_ptr. Only call
kono
parents:
diff changeset
1960 digest_init once on an initializer, we do this just checking
kono
parents:
diff changeset
1961 TREE_TYPE.
kono
parents:
diff changeset
1962 (build_expr_from_tree): Pass current_class_ref to
kono
parents:
diff changeset
1963 build_x_function_call instead of current_class_ptr.
kono
parents:
diff changeset
1964 * init.c (build_member_call): Likewise.
kono
parents:
diff changeset
1965 * pase.y: Likewise.
kono
parents:
diff changeset
1966 * error.c (dump_expr): Handle OFFSET_REFs better.
kono
parents:
diff changeset
1967 * pt.c (unify): Handle pointer-to-member functions better.
kono
parents:
diff changeset
1968 * decl.c (finish_function): Clear out current_class_ref just like
kono
parents:
diff changeset
1969 we do for current_class_ptr.
kono
parents:
diff changeset
1970
kono
parents:
diff changeset
1971 * typeck.c (get_delta_difference): Handle virtual bases better.
kono
parents:
diff changeset
1972
kono
parents:
diff changeset
1973 Tue May 14 16:37:37 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
1974
kono
parents:
diff changeset
1975 * sig.c (build_signature_table_constructor): Use the delta for
kono
parents:
diff changeset
1976 the original basetype for this virtual function with thunks.
kono
parents:
diff changeset
1977 (build_signature_method_call): We still need to adjust 'this'
kono
parents:
diff changeset
1978 with thunks.
kono
parents:
diff changeset
1979
kono
parents:
diff changeset
1980 Tue May 14 16:27:25 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1981
kono
parents:
diff changeset
1982 * call.c (build_addr_func): New routine. Used to get the `real'
kono
parents:
diff changeset
1983 address of a function or a method. Needed to avoid getting a
kono
parents:
diff changeset
1984 pointer-to-member function.
kono
parents:
diff changeset
1985 (build_call): New routine to build CALL_EXPRs.
kono
parents:
diff changeset
1986 (build_method_call): Use it.
kono
parents:
diff changeset
1987 * cvt.c (convert_to_aggr): Likewise.
kono
parents:
diff changeset
1988 * typeck.c (build_function_call_real): Likewise.
kono
parents:
diff changeset
1989 * sig.c (build_signature_table_constructor): Use build_addr_func.
kono
parents:
diff changeset
1990 * cp-tree.h (build_call, build_addr_func): Declare them.
kono
parents:
diff changeset
1991
kono
parents:
diff changeset
1992 Tue May 14 12:47:47 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1993
kono
parents:
diff changeset
1994 * cp-tree.h (LOOKUP_AGGR): Remove, unused.
kono
parents:
diff changeset
1995 * parse.y: Remove uses of LOOKUP_AGGR.
kono
parents:
diff changeset
1996
kono
parents:
diff changeset
1997 Tue May 14 12:07:51 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
1998
kono
parents:
diff changeset
1999 * *.[chy]: Rename current_class_decl to current_class_ptr, and
kono
parents:
diff changeset
2000 C_C_D to current_class_ref.
kono
parents:
diff changeset
2001
kono
parents:
diff changeset
2002 Mon May 13 16:55:23 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2003
kono
parents:
diff changeset
2004 * call.c (convert_harshness): Tighten up pointer conversions.
kono
parents:
diff changeset
2005
kono
parents:
diff changeset
2006 Sat May 11 04:33:50 1996 Doug Evans <dje@canuck.cygnus.com>
kono
parents:
diff changeset
2007
kono
parents:
diff changeset
2008 * decl2.c (finish_vtable_vardecl): Surround DECL_ONE_ONLY with ifdef.
kono
parents:
diff changeset
2009 (finish_file): Likewise.
kono
parents:
diff changeset
2010
kono
parents:
diff changeset
2011 Fri May 10 11:09:57 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2012
kono
parents:
diff changeset
2013 * cvt.c (convert_fn_ptr): We don't use thunks for pmfs.
kono
parents:
diff changeset
2014
kono
parents:
diff changeset
2015 * method.c (emit_thunk): Set flag_omit_frame_pointer in default
kono
parents:
diff changeset
2016 code.
kono
parents:
diff changeset
2017
kono
parents:
diff changeset
2018 Thu May 9 18:18:30 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2019
kono
parents:
diff changeset
2020 * decl2.c: Turn on thunks by default where supported.
kono
parents:
diff changeset
2021
kono
parents:
diff changeset
2022 Tue May 7 20:39:57 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2023
kono
parents:
diff changeset
2024 * cp-tree.h (build_overload_call_maybe): Removed.
kono
parents:
diff changeset
2025 * call.c (build_overload_call_real): Invert meaning of last arg to
kono
parents:
diff changeset
2026 be require_complete.
kono
parents:
diff changeset
2027 (build_overload_call): Likewise.
kono
parents:
diff changeset
2028 * typeck.c (build_x_function_call): Use build_overload_call_real
kono
parents:
diff changeset
2029 instead of build_overload_call_maybe.
kono
parents:
diff changeset
2030
kono
parents:
diff changeset
2031 Mon May 6 01:23:32 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2032
kono
parents:
diff changeset
2033 * decl2.c (finish_file): Don't try to emit functions that haven't
kono
parents:
diff changeset
2034 been compiled.
kono
parents:
diff changeset
2035
kono
parents:
diff changeset
2036 Fri May 3 09:30:13 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2037
kono
parents:
diff changeset
2038 * decl2.c (finish_vtable_vardecl): Oops.
kono
parents:
diff changeset
2039
kono
parents:
diff changeset
2040 * decl.c (maybe_push_to_top_level): Do save previous_class_*.
kono
parents:
diff changeset
2041 Also store the bindings from previous_class_values.
kono
parents:
diff changeset
2042 (pop_from_top_level): Restore them.
kono
parents:
diff changeset
2043
kono
parents:
diff changeset
2044 Thu May 2 21:56:49 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2045
kono
parents:
diff changeset
2046 * decl2.c (finish_vtable_vardecl): Only write out vtable if its
kono
parents:
diff changeset
2047 symbol has been referenced.
kono
parents:
diff changeset
2048 (finish_file): Re-join synthesis/vtable loop with inline emission
kono
parents:
diff changeset
2049 loop, disable inlining when an inline is output.
kono
parents:
diff changeset
2050
kono
parents:
diff changeset
2051 Thu May 2 17:20:02 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2052
kono
parents:
diff changeset
2053 * except.c (init_exception_processing): Setup saved_in_catch.
kono
parents:
diff changeset
2054 (push_eh_cleanup): Reset __eh_in_catch.
kono
parents:
diff changeset
2055 (expand_start_catch_block): Set __eh_in_catch.
kono
parents:
diff changeset
2056
kono
parents:
diff changeset
2057 Thu May 2 16:21:17 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2058
kono
parents:
diff changeset
2059 * except.c (push_eh_cleanup): Add tracking for whether or not we
kono
parents:
diff changeset
2060 have an active exception object.
kono
parents:
diff changeset
2061 (expand_builtin_throw): Use it to make sure a rethrow without an
kono
parents:
diff changeset
2062 exception object is caught.
kono
parents:
diff changeset
2063
kono
parents:
diff changeset
2064 Thu May 2 11:26:41 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2065
kono
parents:
diff changeset
2066 * decl.c (maybe_push_to_top_level): Clear out class-level bindings
kono
parents:
diff changeset
2067 cache.
kono
parents:
diff changeset
2068
kono
parents:
diff changeset
2069 Wed May 1 11:26:52 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2070
kono
parents:
diff changeset
2071 * decl2.c (finish_file): Also use sentries for vars with
kono
parents:
diff changeset
2072 DECL_ONE_ONLY or DECL_WEAK set (should any such happen to be
kono
parents:
diff changeset
2073 created).
kono
parents:
diff changeset
2074
kono
parents:
diff changeset
2075 * lex.c (handle_cp_pragma): Disable #pragma
kono
parents:
diff changeset
2076 interface/implementation if SUPPORTS_ONE_ONLY > 1.
kono
parents:
diff changeset
2077
kono
parents:
diff changeset
2078 Tue Apr 30 11:25:46 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2079
kono
parents:
diff changeset
2080 * method.c (emit_thunk): Wrap default case in
kono
parents:
diff changeset
2081 temporary/permanent_allocation.
kono
parents:
diff changeset
2082
kono
parents:
diff changeset
2083 * method.c (make_thunk): Use DECL_ONE_ONLY.
kono
parents:
diff changeset
2084 (emit_thunk): Call assemble_end_function.
kono
parents:
diff changeset
2085
kono
parents:
diff changeset
2086 Mon Apr 29 15:38:29 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2087
kono
parents:
diff changeset
2088 * decl2.c (import_export_vtable): Use DECL_ONE_ONLY.
kono
parents:
diff changeset
2089 (import_export_decl): Likewise.
kono
parents:
diff changeset
2090 (finish_prevtable_vardecl): Disable vtable hack if
kono
parents:
diff changeset
2091 SUPPORTS_ONE_ONLY > 1.
kono
parents:
diff changeset
2092
kono
parents:
diff changeset
2093 Mon Apr 29 14:32:47 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2094
kono
parents:
diff changeset
2095 * typeck.c (build_modify_expr): PREINCREMENT_EXPR and
kono
parents:
diff changeset
2096 PREDECREMENT_EXPRs take two arguments, not one.
kono
parents:
diff changeset
2097
kono
parents:
diff changeset
2098 Mon Apr 29 00:27:53 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2099
kono
parents:
diff changeset
2100 * class.c (build_vtable_entry): Don't build thunks for abstract
kono
parents:
diff changeset
2101 virtuals.
kono
parents:
diff changeset
2102
kono
parents:
diff changeset
2103 * lex.c (real_yylex): Fix handling of __PRETTY_FUNCTION__ like C
kono
parents:
diff changeset
2104 frontend.
kono
parents:
diff changeset
2105
kono
parents:
diff changeset
2106 Sat Apr 27 16:45:35 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2107
kono
parents:
diff changeset
2108 * class.c (set_rtti_entry): Use size_zero_node.
kono
parents:
diff changeset
2109 (build_vtable): Likewise.
kono
parents:
diff changeset
2110
kono
parents:
diff changeset
2111 Sat Apr 27 14:48:57 1996 Jason Merrill <jason@phydeaux.cygnus.com>
kono
parents:
diff changeset
2112
kono
parents:
diff changeset
2113 * class.c (finish_struct_1): Pass size_zero_node to set_rtti_entry.
kono
parents:
diff changeset
2114 (prepare_fresh_vtable): Likewise.
kono
parents:
diff changeset
2115
kono
parents:
diff changeset
2116 Fri Apr 26 13:14:14 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2117
kono
parents:
diff changeset
2118 * method.c (emit_thunk): Call mark_used on the target function.
kono
parents:
diff changeset
2119
kono
parents:
diff changeset
2120 * call.c (build_method_call): Don't warn about pending templates.
kono
parents:
diff changeset
2121
kono
parents:
diff changeset
2122 Thu Apr 25 14:55:44 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2123
kono
parents:
diff changeset
2124 * decl2.c (finish_file): Fix list walking logic.
kono
parents:
diff changeset
2125
kono
parents:
diff changeset
2126 * typeck2.c (check_for_new_type): Only warn if -pedantic.
kono
parents:
diff changeset
2127
kono
parents:
diff changeset
2128 Wed Apr 24 15:41:15 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2129
kono
parents:
diff changeset
2130 * class.c (finish_struct_1): Remove old code for
kono
parents:
diff changeset
2131 dont_allow_type_definitions.
kono
parents:
diff changeset
2132 * cp-tree.h: Likewise.
kono
parents:
diff changeset
2133 * spew.c: Make sure cp-tree.h is included before parse.h, so the
kono
parents:
diff changeset
2134 definition of flagged_type_tree is found before it is used.
kono
parents:
diff changeset
2135 * lex.c: Likewise.
kono
parents:
diff changeset
2136 * parse.y: Added the ftype member to the type union, and changed a
kono
parents:
diff changeset
2137 number of rules to use it instead of ttype. Added calls to
kono
parents:
diff changeset
2138 check_for_new_type() as appropriate.
kono
parents:
diff changeset
2139 * typeck2.c (check_for_new_type): New function for checking
kono
parents:
diff changeset
2140 if a newly defined type appears in the specified tree.
kono
parents:
diff changeset
2141 * cp-tree.h: Add new type flagged_type_tree. Add a prototype
kono
parents:
diff changeset
2142 for check_for_new_type().
kono
parents:
diff changeset
2143
kono
parents:
diff changeset
2144 Wed Apr 24 00:36:21 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2145
kono
parents:
diff changeset
2146 * decl2.c (finish_file): Only use a sentry if the decl is public.
kono
parents:
diff changeset
2147
kono
parents:
diff changeset
2148 * pt.c (tsubst_expr, DECL_STMT): If we don't have an initializer,
kono
parents:
diff changeset
2149 don't pass LOOKUP_ONLYCONVERTING.
kono
parents:
diff changeset
2150
kono
parents:
diff changeset
2151 Tue Apr 23 17:18:47 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2152
kono
parents:
diff changeset
2153 * typeck.c (common_type): Fix the ARRAY_TYPE case so it
kono
parents:
diff changeset
2154 properly keeps track of const and volatile type modifiers.
kono
parents:
diff changeset
2155
kono
parents:
diff changeset
2156 Tue Apr 23 10:52:56 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2157
kono
parents:
diff changeset
2158 * tree.c (cp_tree_equal): C++ version of simple_cst_equal.
kono
parents:
diff changeset
2159 * pt.c (comp_template_args): Use it.
kono
parents:
diff changeset
2160
kono
parents:
diff changeset
2161 * rtti.c (get_tinfo_fn, build_dynamic_cast, expand_*_desc): Call
kono
parents:
diff changeset
2162 assemble_external for artificial function decls.
kono
parents:
diff changeset
2163
kono
parents:
diff changeset
2164 * decl.c (cp_finish_decl): Oops.
kono
parents:
diff changeset
2165
kono
parents:
diff changeset
2166 Mon Apr 22 17:28:27 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2167
kono
parents:
diff changeset
2168 * decl2.c (import_export_decl): Put static data member templates
kono
parents:
diff changeset
2169 into common storage, or make them weak, depending on whether they
kono
parents:
diff changeset
2170 are dynamically or statically initialized.
kono
parents:
diff changeset
2171 (get_sentry): New function.
kono
parents:
diff changeset
2172 (finish_file): Do import_export_decl for static data members before
kono
parents:
diff changeset
2173 building the init/fini functions. Don't init/fini a variable that's
kono
parents:
diff changeset
2174 EXTERNAL. Use a sentry for variables in common. Fix mismatching
kono
parents:
diff changeset
2175 push/pop_temp_slots.
kono
parents:
diff changeset
2176 * decl.c (cp_finish_decl): If DECL_NOT_REALLY_EXTERN, do the
kono
parents:
diff changeset
2177 expand_static_init thang.
kono
parents:
diff changeset
2178 * method.c (get_id_2): New function.
kono
parents:
diff changeset
2179
kono
parents:
diff changeset
2180 Mon Apr 22 15:32:45 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2181
kono
parents:
diff changeset
2182 * parse.y (empty_parms): Make sure we use C++-style prototypes
kono
parents:
diff changeset
2183 when we're declaring member functions.
kono
parents:
diff changeset
2184
kono
parents:
diff changeset
2185 Sun Apr 21 10:08:22 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2186
kono
parents:
diff changeset
2187 * Makefile.in (CONFLICTS): 16 s/r conflicts.
kono
parents:
diff changeset
2188 * parse.y (self_template_type): New nonterminal.
kono
parents:
diff changeset
2189
kono
parents:
diff changeset
2190 Thu Apr 18 08:56:54 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2191
kono
parents:
diff changeset
2192 * decl.c (make_typename_type): Handle getting a TYPE_DECL for a
kono
parents:
diff changeset
2193 name.
kono
parents:
diff changeset
2194 * parse.y (base_class.1): Allow 'typename foo::bar'.
kono
parents:
diff changeset
2195
kono
parents:
diff changeset
2196 * lex.c (check_newline): Remove #pragma code that plays with the
kono
parents:
diff changeset
2197 input stream, since we now deal with tokens. Clear nextchar when
kono
parents:
diff changeset
2198 we're done.
kono
parents:
diff changeset
2199 (handle_cp_pragma): Use real_yylex.
kono
parents:
diff changeset
2200 (handle_sysv_pragma): Don't do skipline here. Only call real_yylex
kono
parents:
diff changeset
2201 in one place.
kono
parents:
diff changeset
2202
kono
parents:
diff changeset
2203 * lex.c (check_for_missing_semicolon): Handle SELFNAME.
kono
parents:
diff changeset
2204
kono
parents:
diff changeset
2205 * lex.c (handle_cp_pragma): Fix "#pragma implementation".
kono
parents:
diff changeset
2206
kono
parents:
diff changeset
2207 Wed Apr 17 16:51:33 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2208
kono
parents:
diff changeset
2209 * parse.y: New token SELFNAME for potential constructor.
kono
parents:
diff changeset
2210 * spew.c (yylex): Handle it.
kono
parents:
diff changeset
2211 * lex.c (identifier_type): Produce it.
kono
parents:
diff changeset
2212
kono
parents:
diff changeset
2213 * parse.y (complete_type_name): In :: case, don't push class binding.
kono
parents:
diff changeset
2214 (complex_type_name): Likewise.
kono
parents:
diff changeset
2215
kono
parents:
diff changeset
2216 Wed Apr 17 15:02:40 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2217
kono
parents:
diff changeset
2218 * typeck.c (build_reinterpret_cast): Handle pointer to member
kono
parents:
diff changeset
2219 functions.
kono
parents:
diff changeset
2220
kono
parents:
diff changeset
2221 Wed Apr 17 12:28:26 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2222
kono
parents:
diff changeset
2223 * lex.c (handle_cp_pragma): New function, with decl, doing the cc1plus
kono
parents:
diff changeset
2224 pragmas.
kono
parents:
diff changeset
2225 (check_newline): Put the vtable/unit/implementation/interface pragma
kono
parents:
diff changeset
2226 code into handle_cp_pragma, replacing it with a call.
kono
parents:
diff changeset
2227 (handle_sysv_pragma): Give int return type, and take FINPUT and TOKEN
kono
parents:
diff changeset
2228 args. Get the next token after handling the pragma token.
kono
parents:
diff changeset
2229
kono
parents:
diff changeset
2230 Wed Apr 17 10:28:34 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2231
kono
parents:
diff changeset
2232 * cvt.c (cp_convert_to_pointer): Avoid doing base analysis on pmfs.
kono
parents:
diff changeset
2233 (convert_to_pointer_force): Likewise.
kono
parents:
diff changeset
2234
kono
parents:
diff changeset
2235 * init.c (build_new): Fix array new without -fcheck-new.
kono
parents:
diff changeset
2236
kono
parents:
diff changeset
2237 Tue Apr 16 13:44:58 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2238
kono
parents:
diff changeset
2239 * cp-tree.h, call.c, class.c, decl.c, parse.y, pt.c, rtti.c,
kono
parents:
diff changeset
2240 tree.c: Lose TYPE_NESTED_NAME.
kono
parents:
diff changeset
2241
kono
parents:
diff changeset
2242 * parse.y (nested_name_specifier_1): Don't treat non-identifiers
kono
parents:
diff changeset
2243 as identifiers.
kono
parents:
diff changeset
2244
kono
parents:
diff changeset
2245 * tree.def: Add VEC_INIT_EXPR.
kono
parents:
diff changeset
2246 * expr.c (cplus_expand_expr): Handle it.
kono
parents:
diff changeset
2247 * init.c (build_new): Use it instead of the RTL_EXPR nastiness and
kono
parents:
diff changeset
2248 the extra file-scope symbol nastiness.
kono
parents:
diff changeset
2249
kono
parents:
diff changeset
2250 Mon Apr 15 16:21:29 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2251
kono
parents:
diff changeset
2252 * method.c (make_thunk): Thunks are static.
kono
parents:
diff changeset
2253 (emit_thunk): Use ASM_OUTPUT_MI_THUNK if it's defined.
kono
parents:
diff changeset
2254
kono
parents:
diff changeset
2255 * decl2.c (mark_vtable_entries): Emit thunks as needed.
kono
parents:
diff changeset
2256 (finish_file): Don't emit them here.
kono
parents:
diff changeset
2257
kono
parents:
diff changeset
2258 Sun Apr 14 11:34:39 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2259
kono
parents:
diff changeset
2260 * rtti.c (build_dynamic_cast): Handle null pointers.
kono
parents:
diff changeset
2261 (ifnonnull): New function.
kono
parents:
diff changeset
2262
kono
parents:
diff changeset
2263 Fri Apr 12 09:08:27 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2264
kono
parents:
diff changeset
2265 * call.c (build_method_call): Remember the original basetype we
kono
parents:
diff changeset
2266 were called with. Give an error message instead of trying
kono
parents:
diff changeset
2267 (incorrectly) to call a non-static member function through a
kono
parents:
diff changeset
2268 non-inherited class.
kono
parents:
diff changeset
2269
kono
parents:
diff changeset
2270 * search.c (expand_upcast_fixups): Mark the new fixup as
kono
parents:
diff changeset
2271 DECL_ARTIFICIAL.
kono
parents:
diff changeset
2272
kono
parents:
diff changeset
2273 Thu Apr 11 03:57:09 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2274
kono
parents:
diff changeset
2275 * init.c (build_new): Use a TARGET_EXPR for alloc_expr.
kono
parents:
diff changeset
2276
kono
parents:
diff changeset
2277 * class.c (set_rtti_entry): Fix for thunks.
kono
parents:
diff changeset
2278
kono
parents:
diff changeset
2279 * decl2.c (import_export_decl): Still emit typeinfo fns for
kono
parents:
diff changeset
2280 cv-variants of builtin types.
kono
parents:
diff changeset
2281
kono
parents:
diff changeset
2282 * rtti.c (expand_class_desc): Set up base_info_type_node here.
kono
parents:
diff changeset
2283 (init_rtti_processing): Instead of here.
kono
parents:
diff changeset
2284
kono
parents:
diff changeset
2285 Wed Apr 10 14:17:13 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2286
kono
parents:
diff changeset
2287 * rtti.c (init_rtti_processing): Do init regardless of -frtti.
kono
parents:
diff changeset
2288 (build_typeid): Only complain about taking dynamic typeid without
kono
parents:
diff changeset
2289 -frtti.
kono
parents:
diff changeset
2290
kono
parents:
diff changeset
2291 * decl2.c: flag_rtti defaults to 1.
kono
parents:
diff changeset
2292
kono
parents:
diff changeset
2293 * rtti.c (get_tinfo_var): The general class case is now smaller.
kono
parents:
diff changeset
2294 (init_rtti_processing): Pack the latter three fields of base_info
kono
parents:
diff changeset
2295 into 32 bits.
kono
parents:
diff changeset
2296
kono
parents:
diff changeset
2297 Wed Apr 10 13:50:14 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2298
kono
parents:
diff changeset
2299 * init.c (expand_member_init): Don't dump if name is NULL_TREE.
kono
parents:
diff changeset
2300
kono
parents:
diff changeset
2301 Wed Apr 10 12:56:02 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2302
kono
parents:
diff changeset
2303 * search.c (make_memoized_table_entry): Undefer the pop, if necessary.
kono
parents:
diff changeset
2304 (push_memoized_context): Split out code to undefer pop_type_level to
kono
parents:
diff changeset
2305 (clear_memoized_cache): here.
kono
parents:
diff changeset
2306 (pop_memoized_context): We can only handle one layer of deferral of
kono
parents:
diff changeset
2307 pop_type_level so clear the cache, if there was a previous level.
kono
parents:
diff changeset
2308
kono
parents:
diff changeset
2309 Tue Apr 9 23:06:09 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2310
kono
parents:
diff changeset
2311 * rtti.c (init_rtti_processing): Build up base_info_type_node.
kono
parents:
diff changeset
2312 (expand_class_desc): Use one pointer to an array of base_info
kono
parents:
diff changeset
2313 structs, passed using a CONSTRUCTOR.
kono
parents:
diff changeset
2314
kono
parents:
diff changeset
2315 Tue Apr 9 14:20:57 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2316
kono
parents:
diff changeset
2317 * class.c (build_vbase_path): Remove block extern for
kono
parents:
diff changeset
2318 flag_assume_nonnull_objects here.
kono
parents:
diff changeset
2319 (build_vfn_ref): Split out functionality into build_vtbl_ref.
kono
parents:
diff changeset
2320 (build_vtbl_ref): New routine.
kono
parents:
diff changeset
2321 (build_vtable): Set up rtti info here.
kono
parents:
diff changeset
2322 (add_virtual_function): Note in CLASSTYPE_RTTI the best
kono
parents:
diff changeset
2323 place where we can get the rtti pointers from to avoid having to
kono
parents:
diff changeset
2324 search around for a place.
kono
parents:
diff changeset
2325 (finish_base_struct): Likewise.
kono
parents:
diff changeset
2326 (finish_struct_1): Likewise. Never create totally new vtables
kono
parents:
diff changeset
2327 with totally new vtable pointers for rtti. Disable code to layout
kono
parents:
diff changeset
2328 vtable pointers better until we want to break binary
kono
parents:
diff changeset
2329 compatibility.
kono
parents:
diff changeset
2330 * rtti.c (build_headof_sub): New routine to convert down to a
kono
parents:
diff changeset
2331 sub-object that has an rtti pointer in the vtable.
kono
parents:
diff changeset
2332 (build_headof): Use it. Also, use build_vtbl_ref now to be more
kono
parents:
diff changeset
2333 maintainable.
kono
parents:
diff changeset
2334 (build_dynamic_cast): Make sure we have saved it, if we need to.
kono
parents:
diff changeset
2335 * search.c (dfs_init_vbase_pointers): Disable code that deals with
kono
parents:
diff changeset
2336 a more efficient vtable layout, enable later.
kono
parents:
diff changeset
2337 * call.c (flag_assume_nonnull_objects): Moved declaration to
kono
parents:
diff changeset
2338 * cp-tree.h: here. Declare build_vtbl_ref.
kono
parents:
diff changeset
2339 * pt.c (instantiate_class_template): Use NULL_TREE instead of 0 in
kono
parents:
diff changeset
2340 function calls that want a tree.
kono
parents:
diff changeset
2341
kono
parents:
diff changeset
2342 Tue Apr 9 12:10:26 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2343
kono
parents:
diff changeset
2344 * rtti.c (build_dynamic_cast): Handle downcasting to X* given
kono
parents:
diff changeset
2345 other X subobjects in the most derived type. Ack.
kono
parents:
diff changeset
2346
kono
parents:
diff changeset
2347 * rtti.c (build_dynamic_cast): No need to strip cv-quals here,
kono
parents:
diff changeset
2348 get_typeid will do it for us.
kono
parents:
diff changeset
2349 (get_typeid_1): Break out call-building for expand_*_desc to use.
kono
parents:
diff changeset
2350 (get_typeid): Call it.
kono
parents:
diff changeset
2351 (expand_*_desc): Likewise.
kono
parents:
diff changeset
2352 * decl.c (init_decl_processing): Don't set TYPE_BUILT_IN on char *
kono
parents:
diff changeset
2353 and void *.
kono
parents:
diff changeset
2354 (init_decl_processing): Lose builtin_type_tdescs lossage.
kono
parents:
diff changeset
2355 * decl2.c (finish_vtable_vardecl): Remove obsolete code.
kono
parents:
diff changeset
2356
kono
parents:
diff changeset
2357 Mon Apr 8 17:23:23 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2358
kono
parents:
diff changeset
2359 * pt.c (tsubst): When calling set_nested_typename, use
kono
parents:
diff changeset
2360 TYPE_NESTED_NAME (current_class_type) instead of
kono
parents:
diff changeset
2361 current_class_name.
kono
parents:
diff changeset
2362
kono
parents:
diff changeset
2363 * decl.c (pushdecl): Likewise.
kono
parents:
diff changeset
2364 (pushdecl_class_level): Likewise.
kono
parents:
diff changeset
2365 (grokdeclarator): Use NULL_TREE instead of 0 in the call to
kono
parents:
diff changeset
2366 set_nested_typename.
kono
parents:
diff changeset
2367
kono
parents:
diff changeset
2368 Sun Apr 7 10:44:31 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2369
kono
parents:
diff changeset
2370 * rtti.c (synthesize_tinfo_fn): Handle arrays.
kono
parents:
diff changeset
2371
kono
parents:
diff changeset
2372 * cp-tree.h (DECL_REALLY_EXTERN): New macro.
kono
parents:
diff changeset
2373
kono
parents:
diff changeset
2374 Sat Apr 6 13:56:27 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2375
kono
parents:
diff changeset
2376 * rtti.c (throw_bad_cast): Use entry point __throw_bad_cast.
kono
parents:
diff changeset
2377 (init_rtti_processing): Lose bad_cast_type.
kono
parents:
diff changeset
2378 (build_dynamic_cast): Use throw_bad_cast.
kono
parents:
diff changeset
2379
kono
parents:
diff changeset
2380 * rtti.c (synthesize_tinfo_fn): Handle enums and pmfs.
kono
parents:
diff changeset
2381
kono
parents:
diff changeset
2382 * decl2.c (finish_file): Don't synthesize artificial functions
kono
parents:
diff changeset
2383 that are external and not inline.
kono
parents:
diff changeset
2384
kono
parents:
diff changeset
2385 * rtti.c (get_tinfo_fn): If at_eof, call import_export_decl.
kono
parents:
diff changeset
2386
kono
parents:
diff changeset
2387 * decl2.c (finish_file): Handle having new inlines added to
kono
parents:
diff changeset
2388 saved_inlines by synthesis.
kono
parents:
diff changeset
2389
kono
parents:
diff changeset
2390 * rtti.c (get_bad_cast_node): Don't require <typeinfo>.
kono
parents:
diff changeset
2391
kono
parents:
diff changeset
2392 Fri Apr 5 17:02:09 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2393
kono
parents:
diff changeset
2394 RTTI rewrite to initialize nodes as needed, not require that
kono
parents:
diff changeset
2395 users #include <typeinfo>, complete functionality and reduce wasted
kono
parents:
diff changeset
2396 space.
kono
parents:
diff changeset
2397 * rtti.c (init_rtti_processing): New fn.
kono
parents:
diff changeset
2398 (build_typeid): The vtable entry is now a function.
kono
parents:
diff changeset
2399 (get_tinfo_var): New fn.
kono
parents:
diff changeset
2400 (get_tinfo_fn): Likewise.
kono
parents:
diff changeset
2401 (get_typeid): Use it.
kono
parents:
diff changeset
2402 (build_dynamic_cast): Declare and use entry point __dynamic_cast.
kono
parents:
diff changeset
2403 (build_*_desc): Rename to expand_*_desc and rewrite to use entry
kono
parents:
diff changeset
2404 points __rtti_*.
kono
parents:
diff changeset
2405 (add_uninstantiated_desc, get_def_to_follow, build_t_desc): Lose.
kono
parents:
diff changeset
2406 (synthesize_tinfo_fn): New fn.
kono
parents:
diff changeset
2407 * method.c (build_t_desc_overload): Lose.
kono
parents:
diff changeset
2408 (build_overload_with_type): More generic.
kono
parents:
diff changeset
2409 * decl.c (init_decl_processing): Call init_rtti_processing.
kono
parents:
diff changeset
2410 * class.c (set_rtti_entry): Use get_tinfo_fn.
kono
parents:
diff changeset
2411 * decl2.c (mark_vtable_entries): Mark the rtti function.
kono
parents:
diff changeset
2412 (finish_prevtable_vardecl): Don't build_t_desc.
kono
parents:
diff changeset
2413 (import_export_decl): Handle tinfo functions.
kono
parents:
diff changeset
2414 (finish_file): Likewise.
kono
parents:
diff changeset
2415 * typeck.c (inline_conversion): New fn.
kono
parents:
diff changeset
2416 (build_function_call_real): Use it.
kono
parents:
diff changeset
2417 * cp-tree.h: Add decls.
kono
parents:
diff changeset
2418
kono
parents:
diff changeset
2419 * method.c (hack_identifier): Also convert component_refs from
kono
parents:
diff changeset
2420 references.
kono
parents:
diff changeset
2421
kono
parents:
diff changeset
2422 * lex.c (cons_up_default_function): Use the type, not the name, in
kono
parents:
diff changeset
2423 declspecs.
kono
parents:
diff changeset
2424
kono
parents:
diff changeset
2425 * decl2.c (import_export_vtable): Fix weak vtables.
kono
parents:
diff changeset
2426
kono
parents:
diff changeset
2427 Fri Apr 5 13:30:17 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2428
kono
parents:
diff changeset
2429 * search.c (get_base_distance_recursive): Fix access checks for
kono
parents:
diff changeset
2430 protected bases.
kono
parents:
diff changeset
2431
kono
parents:
diff changeset
2432 Fri Apr 5 11:02:06 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2433
kono
parents:
diff changeset
2434 * call.c (unary_complex_lvalue): Delete unneeded decl, it's in
kono
parents:
diff changeset
2435 cp-tree.h.
kono
parents:
diff changeset
2436 (convert_harshness): Add prototypes wrapped by PROTO.
kono
parents:
diff changeset
2437 * decl2.c (grok_function_init): Likewise.
kono
parents:
diff changeset
2438 (do_toplevel_using_decl): Change to void return type.
kono
parents:
diff changeset
2439 * class.c (build_vtable_entry): Remove decl of make_thunk.
kono
parents:
diff changeset
2440 (merge_overrides): Fix order of arg definitions.
kono
parents:
diff changeset
2441 (finish_vtbls): Likewise.
kono
parents:
diff changeset
2442 (fixup_vtable_deltas): Likewise.
kono
parents:
diff changeset
2443 (modify_all_direct_vtables): Likewise.
kono
parents:
diff changeset
2444 (modify_all_indirect_vtables): Likewise.
kono
parents:
diff changeset
2445 * search.c (get_base_distance_recursive): Likewise.
kono
parents:
diff changeset
2446 (get_abstract_virtuals_1): Likewise.
kono
parents:
diff changeset
2447 (fixup_virtual_upcast_offsets): Likewise.
kono
parents:
diff changeset
2448 (lookup_fnfields_1): Add prototypes wrapped by PROTO.
kono
parents:
diff changeset
2449 * init.c (perform_member_init): Fix order of arg definitions.
kono
parents:
diff changeset
2450 (expand_aggr_init_1): Add prototypes wrapped by PROTO.
kono
parents:
diff changeset
2451 * cp-tree.h (make_thunk): Add decl.
kono
parents:
diff changeset
2452 (overload_template_name, push_template_decl): Add decls.
kono
parents:
diff changeset
2453 (do_toplevel_using_decl): Change to void return type.
kono
parents:
diff changeset
2454 (vec_binfo_member): Add decl.
kono
parents:
diff changeset
2455
kono
parents:
diff changeset
2456 Thu Apr 4 13:33:10 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2457
kono
parents:
diff changeset
2458 * typeck.c (mark_addressable, convert_for_assignment,
kono
parents:
diff changeset
2459 convert_for_initialization, pointer_int_sum, pointer_diff,
kono
parents:
diff changeset
2460 unary_complex_lvalue): Add prototypes wrapped by PROTO.
kono
parents:
diff changeset
2461 (convert_sequence): #if 0 fn decl, since definition also is.
kono
parents:
diff changeset
2462
kono
parents:
diff changeset
2463 Thu Apr 4 11:00:53 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2464
kono
parents:
diff changeset
2465 * rtti.c (build_dynamic_cast): Make sure we strip qualifiers on
kono
parents:
diff changeset
2466 cast to pointer types for type searching.
kono
parents:
diff changeset
2467
kono
parents:
diff changeset
2468 Wed Apr 3 17:10:57 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2469
kono
parents:
diff changeset
2470 * typeck.c (get_delta_difference): Use cp_error, not error, in the
kono
parents:
diff changeset
2471 case where BINFO == 0.
kono
parents:
diff changeset
2472
kono
parents:
diff changeset
2473 Wed Apr 3 12:01:02 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2474
kono
parents:
diff changeset
2475 * call.c (build_method_call): Fix wording of error messages so
kono
parents:
diff changeset
2476 constructors come out right.
kono
parents:
diff changeset
2477
kono
parents:
diff changeset
2478 Tue Apr 2 16:06:59 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2479
kono
parents:
diff changeset
2480 * decl.c (push_overloaded_decl): Don't warn about hidden
kono
parents:
diff changeset
2481 constructors when both the type and the function are declared
kono
parents:
diff changeset
2482 in a system header file.
kono
parents:
diff changeset
2483
kono
parents:
diff changeset
2484 Mon Apr 1 09:03:13 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2485
kono
parents:
diff changeset
2486 * class.c (finish_struct_1): Propagate the TYPE_PACKED
kono
parents:
diff changeset
2487 flag for the type to the type's fields.
kono
parents:
diff changeset
2488
kono
parents:
diff changeset
2489 Sat Mar 30 12:14:33 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2490
kono
parents:
diff changeset
2491 * parse.y (complex_parmlist, ELLIPSES): Take out ARM-based warning.
kono
parents:
diff changeset
2492
kono
parents:
diff changeset
2493 Fri Mar 29 15:51:36 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2494
kono
parents:
diff changeset
2495 * class.c (base_info, finish_base_struct): Replace
kono
parents:
diff changeset
2496 needs_virtual_dtor with base_has_virtual.
kono
parents:
diff changeset
2497
kono
parents:
diff changeset
2498 (finish_struct_1): Remove the old code that tried to make default
kono
parents:
diff changeset
2499 destructors virtual. Use base_has_virtual when checking if we need
kono
parents:
diff changeset
2500 to add a vtable entry for the rtti code.
kono
parents:
diff changeset
2501
kono
parents:
diff changeset
2502 Fri Mar 29 14:02:36 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2503
kono
parents:
diff changeset
2504 * pt.c (push_template_decl): Complain about template decl with
kono
parents:
diff changeset
2505 inappropriate declaration.
kono
parents:
diff changeset
2506
kono
parents:
diff changeset
2507 Fri Mar 29 12:15:35 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2508
kono
parents:
diff changeset
2509 * typeck.c (build_x_unary_op): Remove bogus check for taking
kono
parents:
diff changeset
2510 the address of a member function.
kono
parents:
diff changeset
2511
kono
parents:
diff changeset
2512 Fri Mar 29 11:56:02 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2513
kono
parents:
diff changeset
2514 * parse.y (constructor_declarator): Only push the class if
kono
parents:
diff changeset
2515 we are not already in the class.
kono
parents:
diff changeset
2516
kono
parents:
diff changeset
2517 Fri Mar 29 09:41:02 1996 Jeffrey A. Law <law@cygnus.com>
kono
parents:
diff changeset
2518
kono
parents:
diff changeset
2519 * method.c (emit_thunk): Remove current_call_is_indirect nonsense.
kono
parents:
diff changeset
2520 Add additional argument to INIT_CUMULATIVE_ARGS.
kono
parents:
diff changeset
2521
kono
parents:
diff changeset
2522 Thu Mar 28 16:41:39 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2523
kono
parents:
diff changeset
2524 * decl.c (shadow_tag): Fix error about anon union with methods.
kono
parents:
diff changeset
2525
kono
parents:
diff changeset
2526 * parse.y (self_reference): Only generate a self-reference if this
kono
parents:
diff changeset
2527 is a non-template class.
kono
parents:
diff changeset
2528 (opt.component_decl_list): Only use it if it was generated.
kono
parents:
diff changeset
2529
kono
parents:
diff changeset
2530 * parse.y (component_decl_1): Use constructor_declarator.
kono
parents:
diff changeset
2531 (fn.def2): Likewise.
kono
parents:
diff changeset
2532 (notype_component_declarator0): Likewise.
kono
parents:
diff changeset
2533
kono
parents:
diff changeset
2534 Thu Mar 28 15:11:35 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2535
kono
parents:
diff changeset
2536 * typeck.c (build_x_unary_op): Add checks for taking the address
kono
parents:
diff changeset
2537 of a TARGET_EXPR or of a member function, and give appropriate
kono
parents:
diff changeset
2538 warnings.
kono
parents:
diff changeset
2539
kono
parents:
diff changeset
2540 Thu Mar 28 14:49:26 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2541
kono
parents:
diff changeset
2542 * pt.c (process_template_parm): Allow template type parms to be
kono
parents:
diff changeset
2543 used as types for template const parms.
kono
parents:
diff changeset
2544
kono
parents:
diff changeset
2545 Wed Mar 27 15:51:19 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2546
kono
parents:
diff changeset
2547 * init.c (expand_vec_init): Ensure the eh cleanups are on the
kono
parents:
diff changeset
2548 function_obstack.
kono
parents:
diff changeset
2549
kono
parents:
diff changeset
2550 Wed Mar 27 10:14:30 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2551
kono
parents:
diff changeset
2552 * decl.c (lookup_name_real): Be even more picky about the
kono
parents:
diff changeset
2553 ambiguous lookup warning.
kono
parents:
diff changeset
2554 (grokdeclarator): Tweak SCOPE_REF constructor declarators here.
kono
parents:
diff changeset
2555 * parse.y (constructor_declarator): Rather than here.
kono
parents:
diff changeset
2556
kono
parents:
diff changeset
2557 * parse.y (constructor_declarator): New nonterminal.
kono
parents:
diff changeset
2558 (fn.def1): Use it.
kono
parents:
diff changeset
2559 (explicit_instantiation): Likewise.
kono
parents:
diff changeset
2560
kono
parents:
diff changeset
2561 Tue Mar 26 13:41:33 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2562
kono
parents:
diff changeset
2563 Add implicit declaration of class name at class scope.
kono
parents:
diff changeset
2564 * decl.c (lookup_name_real): Restrict pedwarn about ambiguous lookup.
kono
parents:
diff changeset
2565 * parse.y (self_reference): New nonterminal.
kono
parents:
diff changeset
2566 (opt.component_decl_list): Use it.
kono
parents:
diff changeset
2567 (fn.def1): Add nested_name_specifier type_name cases.
kono
parents:
diff changeset
2568 * class.c (build_self_reference): New function.
kono
parents:
diff changeset
2569 (finish_struct): Handle access_default later, move self-reference
kono
parents:
diff changeset
2570 decl to the end.
kono
parents:
diff changeset
2571 * pt.c (lookup_template_class): Handle getting a TYPE_DECL.
kono
parents:
diff changeset
2572 * cp-tree.h: Adjust.
kono
parents:
diff changeset
2573
kono
parents:
diff changeset
2574 * pt.c (do_function_instantiation): Separate handling of member
kono
parents:
diff changeset
2575 functions and non-member functions properly.
kono
parents:
diff changeset
2576
kono
parents:
diff changeset
2577 Mon Mar 25 14:23:22 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2578
kono
parents:
diff changeset
2579 * pt.c (process_template_parm): Improve error for 'volatile class K'.
kono
parents:
diff changeset
2580
kono
parents:
diff changeset
2581 * class.c (finish_struct_1): Check the right slot for destructors.
kono
parents:
diff changeset
2582
kono
parents:
diff changeset
2583 * decl.c (start_enum): Complain about enum templates.
kono
parents:
diff changeset
2584
kono
parents:
diff changeset
2585 Mon Mar 25 13:25:31 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2586
kono
parents:
diff changeset
2587 * init.c (resolve_offset_ref): Offset pointers to member data by one.
kono
parents:
diff changeset
2588 * typeck.c (unary_complex_lvalue): Likewise.
kono
parents:
diff changeset
2589
kono
parents:
diff changeset
2590 Mon Mar 25 13:30:42 1996 Bob Manson <manson@charmed.cygnus.com>
kono
parents:
diff changeset
2591
kono
parents:
diff changeset
2592 * typeck.c (c_expand_return): Check for a returned local
kono
parents:
diff changeset
2593 array name, similar to the check for an ADDR_EXPR.
kono
parents:
diff changeset
2594
kono
parents:
diff changeset
2595 Mon Mar 25 13:07:19 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2596
kono
parents:
diff changeset
2597 * decl.c (cp_finish_decl): Don't build cleanups for static
kono
parents:
diff changeset
2598 variables here.
kono
parents:
diff changeset
2599
kono
parents:
diff changeset
2600 Fri Mar 22 17:57:55 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2601
kono
parents:
diff changeset
2602 * typeck.c (build_modify_expr): Fix error messages to be more
kono
parents:
diff changeset
2603 accurate.
kono
parents:
diff changeset
2604 * cp-tree.h (assop_as_string): Parallel to op_as_string, but for
kono
parents:
diff changeset
2605 assignment operators.
kono
parents:
diff changeset
2606 * error.c (assop_as_string): Likewise. Add support for `%Q' for
kono
parents:
diff changeset
2607 assignment operators.
kono
parents:
diff changeset
2608
kono
parents:
diff changeset
2609 Fri Mar 22 13:48:29 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2610
kono
parents:
diff changeset
2611 * decl.c (grokdeclarator): Call bad_specifiers for typedefs. Also
kono
parents:
diff changeset
2612 give an error if initialized. pedwarn about nested type with the
kono
parents:
diff changeset
2613 same name as its enclosing class.
kono
parents:
diff changeset
2614
kono
parents:
diff changeset
2615 * pt.c (tsubst, case TYPE_DECL): Set DECL_CONTEXT.
kono
parents:
diff changeset
2616
kono
parents:
diff changeset
2617 * typeck.c (require_complete_type): Be sure to instantiate the
kono
parents:
diff changeset
2618 MAIN_VARIANT of the type.
kono
parents:
diff changeset
2619
kono
parents:
diff changeset
2620 * decl2.c (finish_file): Instantiate pending templates before
kono
parents:
diff changeset
2621 processing static constructors and destructors.
kono
parents:
diff changeset
2622
kono
parents:
diff changeset
2623 * pt.c (instantiate_decl): Don't instantiate functions at toplevel
kono
parents:
diff changeset
2624 unless at_eof.
kono
parents:
diff changeset
2625
kono
parents:
diff changeset
2626 Fri Mar 22 09:30:17 1996 Bob Manson <manson@beauty.cygnus.com>
kono
parents:
diff changeset
2627
kono
parents:
diff changeset
2628 * decl2.c (delete_sanity): If error_mark_node is passed
kono
parents:
diff changeset
2629 in as an expression, quit while we're ahead.
kono
parents:
diff changeset
2630
kono
parents:
diff changeset
2631 * decl.c (grokdeclarator): Give an error message if `friend'
kono
parents:
diff changeset
2632 is combined with any storage class specifiers.
kono
parents:
diff changeset
2633
kono
parents:
diff changeset
2634 Wed Mar 20 14:51:55 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2635
kono
parents:
diff changeset
2636 * parse.y (named_complex_class_head_sans_basetype): Don't crash on
kono
parents:
diff changeset
2637 definition of nonexistent nested type.
kono
parents:
diff changeset
2638
kono
parents:
diff changeset
2639 * error.c (dump_decl, case TYPE_DECL): Fix decision for whether or
kono
parents:
diff changeset
2640 not to say 'typedef'.
kono
parents:
diff changeset
2641
kono
parents:
diff changeset
2642 Wed Mar 20 00:11:47 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2643
kono
parents:
diff changeset
2644 * cp-tree.h (struct lang_type): Make search_slot a tree, not a char*.
kono
parents:
diff changeset
2645 * search.c (dfs_walk, dfs_init_vbase_pointers,
kono
parents:
diff changeset
2646 expand_upcast_fixups): Remove cast of CLASSTYPE_SEARCH_SLOT.
kono
parents:
diff changeset
2647 (dfs_find_vbases): Remove cast for CLASSTYPE_SEARCH_SLOT init.
kono
parents:
diff changeset
2648
kono
parents:
diff changeset
2649 Tue Mar 19 17:56:03 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2650
kono
parents:
diff changeset
2651 * except.c (build_throw): Support minimal parse.
kono
parents:
diff changeset
2652 * pt.c (tsubst_copy): Support THROW_EXPR.
kono
parents:
diff changeset
2653 * decl2.c (build_expr_from_tree): Likewise.
kono
parents:
diff changeset
2654
kono
parents:
diff changeset
2655 * pt.c (mangle_class_name_for_template): Always allocate
kono
parents:
diff changeset
2656 scratch_firstobj.
kono
parents:
diff changeset
2657
kono
parents:
diff changeset
2658 Tue Mar 19 16:34:31 1996 Bob Manson <manson@beauty.cygnus.com>
kono
parents:
diff changeset
2659
kono
parents:
diff changeset
2660 * cvt.c (cp_convert_to_pointer): Give an appropriate error
kono
parents:
diff changeset
2661 when trying to cast from an incomplete type.
kono
parents:
diff changeset
2662
kono
parents:
diff changeset
2663 Tue Mar 19 16:00:33 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2664
kono
parents:
diff changeset
2665 * pt.c (instantiate_class_template): Don't bother setting up
kono
parents:
diff changeset
2666 CLASSTYPE_TAGS explicitly, as the nested types will add
kono
parents:
diff changeset
2667 themselves.
kono
parents:
diff changeset
2668
kono
parents:
diff changeset
2669 Tue Mar 19 15:48:43 1996 Bob Manson <manson@beauty.cygnus.com>
kono
parents:
diff changeset
2670
kono
parents:
diff changeset
2671 * decl.c (shadow_tag): Remove old error check for usage of
kono
parents:
diff changeset
2672 an enum without a previous declaration.
kono
parents:
diff changeset
2673 (xref_tag): Add error message about usage of enums without a
kono
parents:
diff changeset
2674 previous declaration.
kono
parents:
diff changeset
2675
kono
parents:
diff changeset
2676 Tue Mar 19 09:21:35 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2677
kono
parents:
diff changeset
2678 * lex.c (do_identifier): Only do name consistency check if we're
kono
parents:
diff changeset
2679 parsing.
kono
parents:
diff changeset
2680
kono
parents:
diff changeset
2681 * pt.c (push_template_decl): Don't crash if we get a member defn
kono
parents:
diff changeset
2682 that doesn't match.
kono
parents:
diff changeset
2683
kono
parents:
diff changeset
2684 * decl.c (xref_tag_from_type): New function to do an xref without
kono
parents:
diff changeset
2685 always having to figure out code_type_node.
kono
parents:
diff changeset
2686 * cp-tree.h: Declare it.
kono
parents:
diff changeset
2687 * pt.c (instantiate_class_template): Use it for friend classes.
kono
parents:
diff changeset
2688 (lookup_template_class): Use it.
kono
parents:
diff changeset
2689
kono
parents:
diff changeset
2690 * typeck2.c (build_functional_cast): Pull out a single parm before
kono
parents:
diff changeset
2691 passing it to build_c_cast.
kono
parents:
diff changeset
2692
kono
parents:
diff changeset
2693 Tue Mar 19 09:07:15 1996 Bob Manson <manson@beauty.cygnus.com>
kono
parents:
diff changeset
2694
kono
parents:
diff changeset
2695 * expr.c (do_case): Give an error message if a pointer is
kono
parents:
diff changeset
2696 given as a case value.
kono
parents:
diff changeset
2697
kono
parents:
diff changeset
2698 Mon Mar 18 21:57:54 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2699
kono
parents:
diff changeset
2700 * typeck.c (build_c_cast): Don't pull single TEMPLATE_DECL out of
kono
parents:
diff changeset
2701 an overload list.
kono
parents:
diff changeset
2702
kono
parents:
diff changeset
2703 * lex.c (cons_up_default_function): Really, now, interface hackery
kono
parents:
diff changeset
2704 does not apply to synthesized methods.
kono
parents:
diff changeset
2705
kono
parents:
diff changeset
2706 Mon Mar 18 18:20:57 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2707
kono
parents:
diff changeset
2708 * call.c (build_method_call): Ctors and dtors now have special names
kono
parents:
diff changeset
2709 with respect to lookups.
kono
parents:
diff changeset
2710 * class.c (add_method): Likewise.
kono
parents:
diff changeset
2711 (grow_method): Likewise.
kono
parents:
diff changeset
2712 (finish_struct_methods): Likewise.
kono
parents:
diff changeset
2713 (warn_hidden): Likewise.
kono
parents:
diff changeset
2714 (finish_struct_1): Likewise.
kono
parents:
diff changeset
2715 * cvt.c (convert_to_reference): Likewise.
kono
parents:
diff changeset
2716 (convert_to_aggr): Likewise.
kono
parents:
diff changeset
2717 (cp_convert): Likewise.
kono
parents:
diff changeset
2718 * decl2.c (check_classfn): Likewise.
kono
parents:
diff changeset
2719 * init.c (expand_member_init): Likewise.
kono
parents:
diff changeset
2720 (expand_default_init): Likewise.
kono
parents:
diff changeset
2721 (expand_aggr_init_1): Likewise.
kono
parents:
diff changeset
2722 (build_offset_ref): Likewise.
kono
parents:
diff changeset
2723 (build_new): Likewise.
kono
parents:
diff changeset
2724 (build_delete): Likewise.
kono
parents:
diff changeset
2725 * lex.c (do_inline_function_hair): Likewise.
kono
parents:
diff changeset
2726 * search.c (lookup_field_1): Likewise.
kono
parents:
diff changeset
2727 (lookup_fnfields_here): Likewise.
kono
parents:
diff changeset
2728 (lookup_field): Likewise.
kono
parents:
diff changeset
2729 (lookup_fnfields): Likewise.
kono
parents:
diff changeset
2730 (get_virtual_destructor): Likewise.
kono
parents:
diff changeset
2731 (dfs_debug_mark): Likewise.
kono
parents:
diff changeset
2732 (dfs_pushdecls): Likewise.
kono
parents:
diff changeset
2733 (dfs_compress_decls): Likewise.
kono
parents:
diff changeset
2734 * tree.c (layout_basetypes): Likewise.
kono
parents:
diff changeset
2735 * typeck.c (build_component_ref): Likewise.
kono
parents:
diff changeset
2736 (build_x_function_call): Likewise.
kono
parents:
diff changeset
2737 (build_modify_expr): Likewise.
kono
parents:
diff changeset
2738 (convert_for_initialization): Likewise.
kono
parents:
diff changeset
2739 (build_functional_cast): Likewise.
kono
parents:
diff changeset
2740 * cp-tree.h (CLASSTYPE_FIRST_CONVERSION): Likewise.
kono
parents:
diff changeset
2741 (CTOR_NAME): New.
kono
parents:
diff changeset
2742 (DTOR_NAME): New.
kono
parents:
diff changeset
2743 * decl.c (ctor_identifier): New.
kono
parents:
diff changeset
2744 (dtor_identifier): New.
kono
parents:
diff changeset
2745 (init_decl_processing): Set them.
kono
parents:
diff changeset
2746
kono
parents:
diff changeset
2747 Mon Mar 18 18:00:51 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2748
kono
parents:
diff changeset
2749 * typeck.c (build_component_ref): Don't get confused by fields whose
kono
parents:
diff changeset
2750 context has no type name, like pointer to member functions.
kono
parents:
diff changeset
2751
kono
parents:
diff changeset
2752 Mon Mar 18 13:19:03 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2753
kono
parents:
diff changeset
2754 * decl.c (grokdeclarator): Handle typedef without declarator.
kono
parents:
diff changeset
2755
kono
parents:
diff changeset
2756 * pt.c (tsubst): Handle SCOPE_REF in declarator.
kono
parents:
diff changeset
2757
kono
parents:
diff changeset
2758 * parse.y (bad_parm): Catch another case of missing `typename'.
kono
parents:
diff changeset
2759
kono
parents:
diff changeset
2760 * lex.c (yyprint): Handle TYPE_DECLs.
kono
parents:
diff changeset
2761
kono
parents:
diff changeset
2762 * decl.c (start_function): Don't try to be clever.
kono
parents:
diff changeset
2763
kono
parents:
diff changeset
2764 * lex.c: Lose compiler_error_with_decl.
kono
parents:
diff changeset
2765 * typeck2.c: Lose error_with_aggr_type.
kono
parents:
diff changeset
2766 (incomplete_type_error): Use cp_* instead of old functions.
kono
parents:
diff changeset
2767 (readonly_error): Likewise.
kono
parents:
diff changeset
2768 * typeck.c (convert_arguments): Likewise.
kono
parents:
diff changeset
2769 * search.c (lookup_nested_field): Likewise.
kono
parents:
diff changeset
2770 * method.c (make_thunk): Likewise.
kono
parents:
diff changeset
2771 * decl.c (grokparms): Likewise.
kono
parents:
diff changeset
2772 * cp-tree.h: Update.
kono
parents:
diff changeset
2773
kono
parents:
diff changeset
2774 * tree.c (min_tree_cons): Call copy_to_permanent for the purpose
kono
parents:
diff changeset
2775 and value.
kono
parents:
diff changeset
2776
kono
parents:
diff changeset
2777 Mon Mar 18 11:25:52 1996 Bob Manson <manson@beauty.cygnus.com>
kono
parents:
diff changeset
2778
kono
parents:
diff changeset
2779 * method.c (build_opfncall): When deleting a pointer to an
kono
parents:
diff changeset
2780 array, build a new pointer to the tree past any ARRAY_TYPE
kono
parents:
diff changeset
2781 nodes.
kono
parents:
diff changeset
2782
kono
parents:
diff changeset
2783 Mon Mar 18 10:11:46 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
2784
kono
parents:
diff changeset
2785 * decl.c (lookup_name_real): Initialize local var TYPE to NULL_TREE.
kono
parents:
diff changeset
2786
kono
parents:
diff changeset
2787 Fri Mar 15 11:03:57 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2788
kono
parents:
diff changeset
2789 * pt.c (instantiate_decl): Only call import_export_decl if at_eof
kono
parents:
diff changeset
2790 and ! DECL_INLINE.
kono
parents:
diff changeset
2791
kono
parents:
diff changeset
2792 * decl.c (finish_function): Don't set nested based on
kono
parents:
diff changeset
2793 hack_decl_function_context.
kono
parents:
diff changeset
2794 * parse.y (function_try_block): Check for nested function.
kono
parents:
diff changeset
2795 (pending_inlines): Likewise.
kono
parents:
diff changeset
2796
kono
parents:
diff changeset
2797 * decl2.c (build_expr_from_tree): If a unary op already has a
kono
parents:
diff changeset
2798 type, just return it.
kono
parents:
diff changeset
2799
kono
parents:
diff changeset
2800 * decl2.c (finish_prevtable_vardecl): Use ADJUST_VTABLE_LINKAGE.
kono
parents:
diff changeset
2801
kono
parents:
diff changeset
2802 * decl2.c (walk_vtables): vardecl_fn returns int; return 1 if it does.
kono
parents:
diff changeset
2803 (finish_file): Check the return value of walk_vtables.
kono
parents:
diff changeset
2804 (finish_prevtable_vardecl): Return int.
kono
parents:
diff changeset
2805 (finish_vtable_vardecl): Likewise.
kono
parents:
diff changeset
2806 (prune_vtable_vardecl): Likewise.
kono
parents:
diff changeset
2807 * lex.c (set_vardecl_interface_info): Likewise.
kono
parents:
diff changeset
2808 * cp-tree.h: Adjust return types.
kono
parents:
diff changeset
2809
kono
parents:
diff changeset
2810 * class.c (delete_duplicate_fields_1): Don't complain about
kono
parents:
diff changeset
2811 duplicate nested types if they're the same type.
kono
parents:
diff changeset
2812 (finish_struct): Remove check for duplicate.
kono
parents:
diff changeset
2813 * decl2.c (grokfield): Don't check for typedef of anonymous type.
kono
parents:
diff changeset
2814
kono
parents:
diff changeset
2815 Thu Mar 14 10:00:19 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2816
kono
parents:
diff changeset
2817 * cp-tree.h: Lose SIGNATURE_GROKKING_TYPEDEF.
kono
parents:
diff changeset
2818
kono
parents:
diff changeset
2819 * decl.c (grokdeclarator): Lose special handling of class-level
kono
parents:
diff changeset
2820 typedef. Lose SIGNATURE_GROKKING_TYPEDEF. Set
kono
parents:
diff changeset
2821 SIGNATURE_HAS_OPAQUE_TYPEDECLS later.
kono
parents:
diff changeset
2822
kono
parents:
diff changeset
2823 * cvt.c (convert_pointer_to_real): Retain cv-quals in conversion.
kono
parents:
diff changeset
2824
kono
parents:
diff changeset
2825 * pt.c (tsubst_copy): Strip cv-quals from destructor name types.
kono
parents:
diff changeset
2826
kono
parents:
diff changeset
2827 * search.c (compute_access): Fix handling of anonymous union
kono
parents:
diff changeset
2828 members.
kono
parents:
diff changeset
2829 * class.c (finish_struct_anon): Propagate TREE_{PRIVATE,PROTECTED}
kono
parents:
diff changeset
2830 from anonymous unions to their members.
kono
parents:
diff changeset
2831
kono
parents:
diff changeset
2832 * typeck.c (build_x_function_call): For static member functions,
kono
parents:
diff changeset
2833 hand off to build_member_call.
kono
parents:
diff changeset
2834
kono
parents:
diff changeset
2835 Wed Mar 13 14:03:34 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2836
kono
parents:
diff changeset
2837 * typeck.c (build_component_ref): Handle OFFSET_REFs.
kono
parents:
diff changeset
2838
kono
parents:
diff changeset
2839 * init.c (expand_vec_init): Fix init == 0 case.
kono
parents:
diff changeset
2840
kono
parents:
diff changeset
2841 Tue Mar 12 14:36:02 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2842
kono
parents:
diff changeset
2843 * init.c (build_new): pedwarn about init and array new.
kono
parents:
diff changeset
2844 (expand_vec_init): Handle lists, use convert_for_initialization.
kono
parents:
diff changeset
2845
kono
parents:
diff changeset
2846 * typeck.c (convert_for_initialization): Pass LOOKUP_NO_CONVERSION
kono
parents:
diff changeset
2847 when converting to an aggregate type.
kono
parents:
diff changeset
2848 * cvt.c (cp_convert): Pass it through.
kono
parents:
diff changeset
2849
kono
parents:
diff changeset
2850 * typeck.c (build_conditional_expr): Handle user-defined
kono
parents:
diff changeset
2851 conversions to slightly different types.
kono
parents:
diff changeset
2852
kono
parents:
diff changeset
2853 * decl.c (grokdeclarator): Force an array type in a parm to be
kono
parents:
diff changeset
2854 permanent.
kono
parents:
diff changeset
2855
kono
parents:
diff changeset
2856 * decl2.c (do_using_directive): Sorry.
kono
parents:
diff changeset
2857 (do_namespace_alias): Likewise.
kono
parents:
diff changeset
2858 * lex.c (real_yylex): Warn about using the `namespace' keyword.
kono
parents:
diff changeset
2859
kono
parents:
diff changeset
2860 Sun Mar 10 22:26:09 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2861
kono
parents:
diff changeset
2862 * parse.y (datadef): Move call to note_list_got_semicolon up.
kono
parents:
diff changeset
2863
kono
parents:
diff changeset
2864 Fri Mar 8 11:47:26 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2865
kono
parents:
diff changeset
2866 * tree.c (unsave_expr): Don't unsave, UNSAVE_EXPRs.
kono
parents:
diff changeset
2867
kono
parents:
diff changeset
2868 Fri Mar 8 11:29:06 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2869
kono
parents:
diff changeset
2870 * decl.c (cp_finish_decl): The exception regions have to be
kono
parents:
diff changeset
2871 nested, not overlapping. We start the exception region for a
kono
parents:
diff changeset
2872 decl, after it has been fully built, and all temporaries for it
kono
parents:
diff changeset
2873 have been cleaned up.
kono
parents:
diff changeset
2874
kono
parents:
diff changeset
2875 Thu Mar 7 17:46:06 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2876
kono
parents:
diff changeset
2877 * tree.c (vec_binfo_member): Don't core dump if we have no bases.
kono
parents:
diff changeset
2878
kono
parents:
diff changeset
2879 Thu Mar 7 14:11:49 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2880
kono
parents:
diff changeset
2881 * tree.def: Add RETURN_INIT.
kono
parents:
diff changeset
2882 * pt.c (instantiate_decl): Handle RETURN_INIT.
kono
parents:
diff changeset
2883 * decl.c (store_return_init): Handle minimal_parse_mode.
kono
parents:
diff changeset
2884
kono
parents:
diff changeset
2885 * tree.c (cp_build_type_variant): Just return an error_mark_node.
kono
parents:
diff changeset
2886 * decl.c (make_typename_type): Don't try to get the file and line
kono
parents:
diff changeset
2887 of an identifier.
kono
parents:
diff changeset
2888 * typeck.c (comptypes): Handle TYPENAME_TYPE.
kono
parents:
diff changeset
2889
kono
parents:
diff changeset
2890 Wed Mar 6 18:47:50 1996 Per Bothner <bothner@kalessin.cygnus.com>
kono
parents:
diff changeset
2891
kono
parents:
diff changeset
2892 * decl.c (poplevel): Make sure we clear out and restore old local
kono
parents:
diff changeset
2893 non-VAR_DECL values by default when they go out of scope.
kono
parents:
diff changeset
2894
kono
parents:
diff changeset
2895 Wed Mar 6 09:57:36 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2896
kono
parents:
diff changeset
2897 * method.c (build_overload_value): Use DECL_ASSEMBLER_NAME in
kono
parents:
diff changeset
2898 referring to addresses of variables and functions.
kono
parents:
diff changeset
2899
kono
parents:
diff changeset
2900 * error.c (dump_expr): Support SIZEOF_EXPR.
kono
parents:
diff changeset
2901
kono
parents:
diff changeset
2902 * init.c (do_friend): Use the return value of check_classfn.
kono
parents:
diff changeset
2903
kono
parents:
diff changeset
2904 * typeck.c (convert_arguments): Call complete_type.
kono
parents:
diff changeset
2905
kono
parents:
diff changeset
2906 * method.c (hack_identifier): After giving an error, set value to
kono
parents:
diff changeset
2907 error_mark_node.
kono
parents:
diff changeset
2908
kono
parents:
diff changeset
2909 Tue Mar 5 16:00:15 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2910
kono
parents:
diff changeset
2911 * tree.c (hack_decl_function_context): Kludge around DECL_CONTEXT
kono
parents:
diff changeset
2912 lossage for local classes.
kono
parents:
diff changeset
2913 * cp-tree.h: Declare it.
kono
parents:
diff changeset
2914 * decl.c (lookup_name_real): Evil, painful hack for local classes.
kono
parents:
diff changeset
2915 (grokfndecl): Set DECL_CLASS_CONTEXT and DECL_NO_STATIC_CHAIN here.
kono
parents:
diff changeset
2916 Use hack_decl_function_context.
kono
parents:
diff changeset
2917 (grokdeclarator): Don't set DECL_NO_STATIC_CHAIN here.
kono
parents:
diff changeset
2918 (start_function): Use hack_decl_function_context.
kono
parents:
diff changeset
2919 (finish_function): Likewise.
kono
parents:
diff changeset
2920 * method.c (synthesize_method): Likewise.
kono
parents:
diff changeset
2921 * lex.c (process_next_inline): Likewise.
kono
parents:
diff changeset
2922 (do_pending_inlines): Likewise.
kono
parents:
diff changeset
2923 * decl2.c (finish_file): Unset DECL_STATIC_FUNCTION_P when we're
kono
parents:
diff changeset
2924 done with it.
kono
parents:
diff changeset
2925
kono
parents:
diff changeset
2926 Mon Mar 4 22:38:39 1996 Gerald Baumgartner <gb@alexander.cs.purdue.edu>
kono
parents:
diff changeset
2927
kono
parents:
diff changeset
2928 * sig.c (build_signature_pointer_or_reference_type): Align
kono
parents:
diff changeset
2929 signature pointers/references on 8-byte boundaries so they can be
kono
parents:
diff changeset
2930 grabbed 2 words at a time on a SPARC.
kono
parents:
diff changeset
2931
kono
parents:
diff changeset
2932 Tue Mar 5 10:21:01 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2933
kono
parents:
diff changeset
2934 * method.c (hack_identifier): Requiring a static chain is now a
kono
parents:
diff changeset
2935 hard error.
kono
parents:
diff changeset
2936 * decl.c (grokdeclarator): Set DECL_NO_STATIC_CHAIN on nested
kono
parents:
diff changeset
2937 functions.
kono
parents:
diff changeset
2938
kono
parents:
diff changeset
2939 Mon Mar 4 20:03:33 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2940
kono
parents:
diff changeset
2941 * init.c (build_offset_ref): Call complete_type.
kono
parents:
diff changeset
2942
kono
parents:
diff changeset
2943 * decl.c (pop_from_top_level): Always pop previous_class_type.
kono
parents:
diff changeset
2944
kono
parents:
diff changeset
2945 * parse.y: Handle multiple decls in a for-init-statement.
kono
parents:
diff changeset
2946 * pt.c (tsubst_expr): Likewise.
kono
parents:
diff changeset
2947
kono
parents:
diff changeset
2948 * pt.c (tsubst): Use tsubst_expr for the second operand of an
kono
parents:
diff changeset
2949 ARRAY_REF.
kono
parents:
diff changeset
2950
kono
parents:
diff changeset
2951 * decl.c (maybe_push_to_top_level): Don't save previous_class_type.
kono
parents:
diff changeset
2952 (poplevel_class): Set it here.
kono
parents:
diff changeset
2953 (pop_from_top_level): Pop it here if we're returning to class scope.
kono
parents:
diff changeset
2954 * class.c (pushclass): Don't set it here.
kono
parents:
diff changeset
2955
kono
parents:
diff changeset
2956 * decl.c (maybe_push_to_top_level): Save current_template_parms,
kono
parents:
diff changeset
2957 and clear it if !pseudo.
kono
parents:
diff changeset
2958 (pop_from_top_level): Restore it.
kono
parents:
diff changeset
2959
kono
parents:
diff changeset
2960 * decl2.c (finish_file): Push the dummy each time we walk the list
kono
parents:
diff changeset
2961 of vtables.
kono
parents:
diff changeset
2962
kono
parents:
diff changeset
2963 * error.c (dump_expr): Support LOOKUP_EXPR and actually do
kono
parents:
diff changeset
2964 something for CAST_EXPR.
kono
parents:
diff changeset
2965
kono
parents:
diff changeset
2966 Mon Feb 19 14:49:18 1996 Rusty Russell <rusty@adelaide.maptek.com.au>
kono
parents:
diff changeset
2967
kono
parents:
diff changeset
2968 * cvt.c (cp_convert): Warn about implicit conversion of the
kono
parents:
diff changeset
2969 address of a function to bool, as it is always true.
kono
parents:
diff changeset
2970
kono
parents:
diff changeset
2971 Fri Feb 23 23:06:01 1996 Rusty Russell <rusty@adelaide.maptek.com.au>
kono
parents:
diff changeset
2972
kono
parents:
diff changeset
2973 * typeck.c (c_expand_return): Fix warning for local externs returned.
kono
parents:
diff changeset
2974
kono
parents:
diff changeset
2975 Mon Mar 4 15:03:11 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2976
kono
parents:
diff changeset
2977 * tree.c (mapcar): Propagate const and volatile properly.
kono
parents:
diff changeset
2978
kono
parents:
diff changeset
2979 * typeck.c (complete_type): Be sure to instantiate the
kono
parents:
diff changeset
2980 MAIN_VARIANT of the type.
kono
parents:
diff changeset
2981
kono
parents:
diff changeset
2982 * method.c (synthesize_method): Class interface hackery does not
kono
parents:
diff changeset
2983 apply to synthesized methods.
kono
parents:
diff changeset
2984
kono
parents:
diff changeset
2985 Mon Mar 4 14:05:23 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2986
kono
parents:
diff changeset
2987 * pt.c (comp_template_args): Use comptypes rather than just
kono
parents:
diff changeset
2988 checking for TEMPLATE_TYPE_PARM equivalence.
kono
parents:
diff changeset
2989
kono
parents:
diff changeset
2990 * typeck.c (build_x_function_call): Call complete_type before
kono
parents:
diff changeset
2991 checking TYPE_OVERLOADS_CALL_EXPR.
kono
parents:
diff changeset
2992
kono
parents:
diff changeset
2993 Mon Mar 4 18:48:30 1996 Manfred Hollstein <manfred@lts.sel.alcatel.de>
kono
parents:
diff changeset
2994
kono
parents:
diff changeset
2995 * g++.c (main): Check also for new define ALT_LIBM.
kono
parents:
diff changeset
2996
kono
parents:
diff changeset
2997 Fri Mar 1 13:09:33 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
2998
kono
parents:
diff changeset
2999 * pt.c (instantiate_class_template): If we don't have a pattern
kono
parents:
diff changeset
3000 yet, that's OK.
kono
parents:
diff changeset
3001 (coerce_template_parms): If we see a local class, bail.
kono
parents:
diff changeset
3002
kono
parents:
diff changeset
3003 * decl.c (grok_reference_init): Make sure there's a type before
kono
parents:
diff changeset
3004 checking its code.
kono
parents:
diff changeset
3005
kono
parents:
diff changeset
3006 * pt.c (do_function_instantiation): Avoid crashing on invalid decls.
kono
parents:
diff changeset
3007 (push_template_decl): Likewise.
kono
parents:
diff changeset
3008
kono
parents:
diff changeset
3009 * parse.y (named_class_head): Set
kono
parents:
diff changeset
3010 CLASSTYPE_TEMPLATE_SPECIALIZATION here if we have basetypes.
kono
parents:
diff changeset
3011
kono
parents:
diff changeset
3012 * decl.c (xref_tag): Diagnose redeclaration of template
kono
parents:
diff changeset
3013 type-parameter name.
kono
parents:
diff changeset
3014
kono
parents:
diff changeset
3015 * error.c (dump_type): Handle anonymous template type parms.
kono
parents:
diff changeset
3016
kono
parents:
diff changeset
3017 * pt.c (instantiate_template): Use TYPE_MAIN_DECL instead of
kono
parents:
diff changeset
3018 TYPE_STUB_DECL.
kono
parents:
diff changeset
3019 (coerce_template_parms): Likewise.
kono
parents:
diff changeset
3020
kono
parents:
diff changeset
3021 Thu Feb 29 16:26:01 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3022
kono
parents:
diff changeset
3023 * class.c (instantiate_type, case {ARRAY,INDIRECT}_REF,
kono
parents:
diff changeset
3024 case ADDR_EXPR): Don't modify rhs if a subinstantiation fails.
kono
parents:
diff changeset
3025
kono
parents:
diff changeset
3026 Thu Feb 29 08:20:25 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3027
kono
parents:
diff changeset
3028 * pt.c (instantiate_template): Take the MAIN_VARIANT of the type
kono
parents:
diff changeset
3029 before trying to get its STUB_DECL.
kono
parents:
diff changeset
3030 (coerce_template_parms): Likewise.
kono
parents:
diff changeset
3031
kono
parents:
diff changeset
3032 * parse.y (template_type_parm): If they didn't use 'class',
kono
parents:
diff changeset
3033 pretend they did after giving an error.
kono
parents:
diff changeset
3034
kono
parents:
diff changeset
3035 * pt.c (coerce_template_parms): Diagnose use of local class.
kono
parents:
diff changeset
3036
kono
parents:
diff changeset
3037 * decl.c (grok_reference_init): Use instantiate_type.
kono
parents:
diff changeset
3038
kono
parents:
diff changeset
3039 * error.c (dump_expr): Handle TEMPLATE_DECLs.
kono
parents:
diff changeset
3040
kono
parents:
diff changeset
3041 * parse.y (named_class_head): Diagnose mismatching types and tags.
kono
parents:
diff changeset
3042
kono
parents:
diff changeset
3043 * decl.c (pushdecl): Type decls and class templates clash with
kono
parents:
diff changeset
3044 artificial type decls, not hide them.
kono
parents:
diff changeset
3045
kono
parents:
diff changeset
3046 * decl.c (redeclaration_error_message): Diagnose redefinition of
kono
parents:
diff changeset
3047 templates properly.
kono
parents:
diff changeset
3048 (duplicate_decls): Diagnose disallowed overloads for template
kono
parents:
diff changeset
3049 functions, too.
kono
parents:
diff changeset
3050
kono
parents:
diff changeset
3051 * decl.c (start_decl): Call complete_type before checking for a
kono
parents:
diff changeset
3052 destructor.
kono
parents:
diff changeset
3053
kono
parents:
diff changeset
3054 * pt.c (tsubst): Use tsubst_expr on the elts of a VEC.
kono
parents:
diff changeset
3055
kono
parents:
diff changeset
3056 * decl.c (xref_tag): A TEMPLATE_TYPE_PARM is a match.
kono
parents:
diff changeset
3057
kono
parents:
diff changeset
3058 Wed Feb 28 09:28:44 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3059
kono
parents:
diff changeset
3060 * decl.c (grok_op_properties): Don't check for operator++(int) in
kono
parents:
diff changeset
3061 a template.
kono
parents:
diff changeset
3062
kono
parents:
diff changeset
3063 * tree.c (perm_manip): Return a copy of variable and function
kono
parents:
diff changeset
3064 decls with external linkage.
kono
parents:
diff changeset
3065
kono
parents:
diff changeset
3066 * tree.def: Change some of the min tree codes to type "1".
kono
parents:
diff changeset
3067 * pt.c (uses_template_parms): Handle 'e's, return 1 for LOOKUP_EXPRs.
kono
parents:
diff changeset
3068 * method.c (build_overload_int): Emit something arbitrary for
kono
parents:
diff changeset
3069 anything but an INTEGER_CST if we're in a template.
kono
parents:
diff changeset
3070
kono
parents:
diff changeset
3071 * decl.c (cp_finish_decl): Call complete_type before deciding
kono
parents:
diff changeset
3072 whether or not to lay out the decl.
kono
parents:
diff changeset
3073
kono
parents:
diff changeset
3074 * lex.c (do_identifier): Check for DECL_INITIAL before using it.
kono
parents:
diff changeset
3075
kono
parents:
diff changeset
3076 Tue Feb 27 16:35:32 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3077
kono
parents:
diff changeset
3078 * typeck2.c (build_x_arrow): Call complete_type.
kono
parents:
diff changeset
3079
kono
parents:
diff changeset
3080 * pt.c (add_pending_template): Broken out.
kono
parents:
diff changeset
3081 (lookup_template_class): If -fexternal-templates, call it for all
kono
parents:
diff changeset
3082 the methods of implemented types.
kono
parents:
diff changeset
3083 (instantiate_class_template): Instead of instantiating them here.
kono
parents:
diff changeset
3084 (instantiate_decl): Handle -fexternal-templates earlier.
kono
parents:
diff changeset
3085
kono
parents:
diff changeset
3086 Tue Feb 27 15:51:32 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3087
kono
parents:
diff changeset
3088 * search.c, lex.c, decl.c, class.c, cp-tree.h: Don't wrap the
kono
parents:
diff changeset
3089 memoized lookup stuff inside GATHER_STATISTICS.
kono
parents:
diff changeset
3090
kono
parents:
diff changeset
3091 Tue Feb 27 10:38:08 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3092
kono
parents:
diff changeset
3093 * decl.c (start_decl): Complain about array of incomplete type
kono
parents:
diff changeset
3094 here.
kono
parents:
diff changeset
3095 (grokdeclarator): Not here.
kono
parents:
diff changeset
3096
kono
parents:
diff changeset
3097 * parse.y (template_parm): Expand full_parm inline so we can set
kono
parents:
diff changeset
3098 the rule's precedence.
kono
parents:
diff changeset
3099
kono
parents:
diff changeset
3100 * pt.c (tsubst_expr): If we're in a template, just do tsubst_copy.
kono
parents:
diff changeset
3101 (tsubst): tsubst_expr the DECL_INITIAL of FIELD_DECLs.
kono
parents:
diff changeset
3102 * decl2.c (grokbitfield): Don't check for integer constant here.
kono
parents:
diff changeset
3103 * class.c (finish_struct_1): Check here.
kono
parents:
diff changeset
3104
kono
parents:
diff changeset
3105 * decl.c (define_label): Make the min decl go on permanent_obstack.
kono
parents:
diff changeset
3106
kono
parents:
diff changeset
3107 * pt.c (unify): Don't handle CONST_DECLs.
kono
parents:
diff changeset
3108 (uses_template_parms): Don't check DECL_INITIAL on a CONST_DECL.
kono
parents:
diff changeset
3109 (tsubst_copy): Likewise.
kono
parents:
diff changeset
3110
kono
parents:
diff changeset
3111 * lex.c (do_identifier): Do pull the DECL_INITIAL out of a
kono
parents:
diff changeset
3112 CONST_DECL for a template parm.
kono
parents:
diff changeset
3113
kono
parents:
diff changeset
3114 Mon Feb 26 12:48:18 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3115
kono
parents:
diff changeset
3116 * decl.c (grokdeclarator): Complain about array of incomplete type
kono
parents:
diff changeset
3117 here.
kono
parents:
diff changeset
3118 (start_decl_1): Not here.
kono
parents:
diff changeset
3119
kono
parents:
diff changeset
3120 * pt.c (tsubst): Handle pointer-to-function declarators.
kono
parents:
diff changeset
3121
kono
parents:
diff changeset
3122 * method.c (hack_identifier): If pedantic, diagnose local class
kono
parents:
diff changeset
3123 methods that require a static chain.
kono
parents:
diff changeset
3124
kono
parents:
diff changeset
3125 * decl.c (grok_op_properties): No longer static.
kono
parents:
diff changeset
3126 * cp-tree.h: Declare it.
kono
parents:
diff changeset
3127 * pt.c (tsubst): Call it for operators.
kono
parents:
diff changeset
3128 Use tsubst_copy for TREE_VECs.
kono
parents:
diff changeset
3129
kono
parents:
diff changeset
3130 * parse.y (template_arg): The expr has precedence like '>'.
kono
parents:
diff changeset
3131
kono
parents:
diff changeset
3132 Fri Feb 23 14:51:52 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3133
kono
parents:
diff changeset
3134 * pt.c (coerce_template_parms): Don't coerce an expression using
kono
parents:
diff changeset
3135 template parms.
kono
parents:
diff changeset
3136 (uses_template_parms): Also check DECL_INITIAL in CONST_DECLs.
kono
parents:
diff changeset
3137 (tsubst): Don't use build_index_2_type if the max_value uses template
kono
parents:
diff changeset
3138 parms.
kono
parents:
diff changeset
3139 * method.c (build_overload_int): Emit something arbitrary for an
kono
parents:
diff changeset
3140 expression using template parms.
kono
parents:
diff changeset
3141
kono
parents:
diff changeset
3142 * parse.y (template_close_bracket): New non-terminal to catch use
kono
parents:
diff changeset
3143 of '>>' instead of '> >' in template class names.
kono
parents:
diff changeset
3144 (template_type): Use it.
kono
parents:
diff changeset
3145 * Makefile.in (CONFLICTS): Causes one more r/r conflict.
kono
parents:
diff changeset
3146
kono
parents:
diff changeset
3147 * tree.def: Add CAST_EXPR.
kono
parents:
diff changeset
3148 * typeck2.c (build_functional_cast): Use CAST_EXPR instead of
kono
parents:
diff changeset
3149 CONVERT_EXPR for minimal_parse_mode.
kono
parents:
diff changeset
3150 * typeck.c (build_c_cast): Likewise.
kono
parents:
diff changeset
3151 * pt.c (tsubst_copy): Likewise.
kono
parents:
diff changeset
3152 * decl2.c (build_expr_from_tree): Likewise.
kono
parents:
diff changeset
3153 * error.c (dump_expr): Likewise.
kono
parents:
diff changeset
3154
kono
parents:
diff changeset
3155 Fri Feb 23 10:36:46 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3156
kono
parents:
diff changeset
3157 * except.c (SetTerminate, SetUnexpected): Put back global vars.
kono
parents:
diff changeset
3158 (init_exception_processing): Put back decl/init of
kono
parents:
diff changeset
3159 set_unexpected_fndecl and set_terminate_fndecl, needed to get the
kono
parents:
diff changeset
3160 fns from libstdc++.
kono
parents:
diff changeset
3161
kono
parents:
diff changeset
3162 * decl.c (struct binding_level): Delete ACCEPT_ANY bitfield.
kono
parents:
diff changeset
3163 (declare_uninstantiated_type_level, uninstantiated_type_level_p):
kono
parents:
diff changeset
3164 Delete unused fns.
kono
parents:
diff changeset
3165 * cp-tree.h (declare_uninstantiated_type_level,
kono
parents:
diff changeset
3166 uninstantiated_type_level_p): Delete prototypes.
kono
parents:
diff changeset
3167
kono
parents:
diff changeset
3168 Thu Feb 22 19:36:15 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3169
kono
parents:
diff changeset
3170 * pt.c (tsubst_expr): Add default return.
kono
parents:
diff changeset
3171
kono
parents:
diff changeset
3172 Thu Feb 22 16:47:24 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3173
kono
parents:
diff changeset
3174 * error.c (fndecl_as_string): Delete unused arg CNAME.
kono
parents:
diff changeset
3175 * sig.c (build_signature_table_constructor,
kono
parents:
diff changeset
3176 build_signature_method_call): Fix calls.
kono
parents:
diff changeset
3177
kono
parents:
diff changeset
3178 * class.c (the_null_vtable_entry): Delete var definition.
kono
parents:
diff changeset
3179 (init_class_processing): Delete tree the_null_vtable_entry init.
kono
parents:
diff changeset
3180 * decl.c (no_print_{functions, builtins}): Declare as static.
kono
parents:
diff changeset
3181 (__tp_desc_type_node): #if 0 var definition.
kono
parents:
diff changeset
3182 (init_type_desc): #if 0 init of __tp_desc_type_node.
kono
parents:
diff changeset
3183 (vb_off_identifier): Move var decl into init_decl_processing.
kono
parents:
diff changeset
3184 (current_function_assigns_this): Declare as static.
kono
parents:
diff changeset
3185 (int_ftype_ptr_ptr_int, void_ftype_ptr_int_int): Delete var decls.
kono
parents:
diff changeset
3186 (init_decl_processing): Delete init of void_ftype_ptr_ptr_int.
kono
parents:
diff changeset
3187 Move decls of string_ftype_ptr_ptr and int_ftype_string_string here.
kono
parents:
diff changeset
3188 * decl2.c (delete_sanity): Delete definition/mod of local var ELT_SIZE.
kono
parents:
diff changeset
3189 * init.c (BI_header_type, BI_header_size): Declare as static.
kono
parents:
diff changeset
3190 * pt.c (template_classes): Delete unused var.
kono
parents:
diff changeset
3191 (add_pending_template): Delete decl for non-existent fn.
kono
parents:
diff changeset
3192 (lookup_template_class): Delete vars CODE and TAG_CODE.
kono
parents:
diff changeset
3193 (instantiate_template): Delete unused var TARGS.
kono
parents:
diff changeset
3194 * cp-tree.h (vb_off_identifier, current_function_assigns_this):
kono
parents:
diff changeset
3195 Delete decls.
kono
parents:
diff changeset
3196 (__tp_desc_type_node): #if 0 var decl.
kono
parents:
diff changeset
3197 (fndecl_as_string): Fix prototype.
kono
parents:
diff changeset
3198
kono
parents:
diff changeset
3199 Thu Feb 22 15:56:19 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3200
kono
parents:
diff changeset
3201 * tree.def: Add GOTO_STMT.
kono
parents:
diff changeset
3202 * pt.c (tsubst_expr): Support goto and labels.
kono
parents:
diff changeset
3203 * decl.c (define_label): Support minimal parsing.
kono
parents:
diff changeset
3204 * parse.y (simple_stmt): Likewise.
kono
parents:
diff changeset
3205
kono
parents:
diff changeset
3206 Thu Feb 22 15:30:12 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3207
kono
parents:
diff changeset
3208 * xref.c (GNU_xref_member): Only define/set var I if
kono
parents:
diff changeset
3209 XREF_SHORT_MEMBER_NAMES is defined, to match when it's actually
kono
parents:
diff changeset
3210 used.
kono
parents:
diff changeset
3211 (GNU_xref_end_scope): Delete unused fifth arg TRNS.
kono
parents:
diff changeset
3212 (GNU_xref_end): Fix call.
kono
parents:
diff changeset
3213 * decl.c (poplevel, poplevel_class, finish_method): Fix calls.
kono
parents:
diff changeset
3214 * cp-tree.h (GNU_xref_end_scope): Fix prototype.
kono
parents:
diff changeset
3215
kono
parents:
diff changeset
3216 * tree.c (build_exception_variant): Delete unused vars I, A, T,
kono
parents:
diff changeset
3217 T2, and CNAME.
kono
parents:
diff changeset
3218 (layout_vbasetypes): Delete unused var NONVIRTUAL_VAR_SIZE.
kono
parents:
diff changeset
3219 (mapcar): Delete unused var CODE.
kono
parents:
diff changeset
3220 (build_cplus_new): Delete unused arg WITH_CLEANUP_P.
kono
parents:
diff changeset
3221 (break_out_cleanups): Fix call.
kono
parents:
diff changeset
3222 (bot_manip): Likewise.
kono
parents:
diff changeset
3223 * call.c (build_method_call): Likewise.
kono
parents:
diff changeset
3224 * cvt.c (build_up_reference, convert_to_reference, cp_convert):
kono
parents:
diff changeset
3225 Likewise.
kono
parents:
diff changeset
3226 * typeck.c (unary_complex_lvalue, build_modify_expr,
kono
parents:
diff changeset
3227 convert_for_initialization): Likewise.
kono
parents:
diff changeset
3228 * typeck2.c (build_functional_cast): Likewise.
kono
parents:
diff changeset
3229 * cp-tree.h (build_cplus_new): Fix prototype.
kono
parents:
diff changeset
3230
kono
parents:
diff changeset
3231 * repo.c (open_repo_file): Delete unused var Q.
kono
parents:
diff changeset
3232 (repo_compile_flags, repo_template_declared,
kono
parents:
diff changeset
3233 repo_template_defined, repo_class_defined, repo_inline_used,
kono
parents:
diff changeset
3234 repo_vtable_used, repo_tinfo_used): #if 0 unused fns.
kono
parents:
diff changeset
3235 (repo_get_id, repo_vtable_used): Declare as static.
kono
parents:
diff changeset
3236 * cp-tree.h (mark_{decl,class}_instantiated, finish_repo): Add
kono
parents:
diff changeset
3237 prototypes.
kono
parents:
diff changeset
3238
kono
parents:
diff changeset
3239 Thu Feb 22 14:53:35 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3240
kono
parents:
diff changeset
3241 * parse.y (pending_inlines): Add function_try_block case.
kono
parents:
diff changeset
3242
kono
parents:
diff changeset
3243 * pt.c (unify): Fix for template const parms.
kono
parents:
diff changeset
3244
kono
parents:
diff changeset
3245 Thu Feb 22 13:24:15 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3246
kono
parents:
diff changeset
3247 * lex.c (extract_interface_info): Delete forward decl.
kono
parents:
diff changeset
3248 (default_copy_constructor_body, default_assign_ref_body): Delete
kono
parents:
diff changeset
3249 decls for non-existent functions.
kono
parents:
diff changeset
3250 (synth_firstobj, inline_text_firstobjs): Delete unused vars.
kono
parents:
diff changeset
3251 (init_lex): Delete setting them.
kono
parents:
diff changeset
3252 (cons_up_default_function): Delete unused vars FUNC_BUF,
kono
parents:
diff changeset
3253 FUNC_LEN, and COMPLEX. Delete code setting COMPLEX. Delete old
kono
parents:
diff changeset
3254 #if 0'd synth code.
kono
parents:
diff changeset
3255 (toplevel, expression_obstack): Delete unused extern decls.
kono
parents:
diff changeset
3256 (tree_node_kind): Delete unused enum.
kono
parents:
diff changeset
3257 (tree_node_counts, tree_node_sizes): Wrap with #ifdef
kono
parents:
diff changeset
3258 GATHER_STATISTICS.
kono
parents:
diff changeset
3259 (tree_node_kind_names): Delete unused extern decl.
kono
parents:
diff changeset
3260 (synth_obstack): Delete unused var.
kono
parents:
diff changeset
3261 (init_lex): Don't set it.
kono
parents:
diff changeset
3262 (init_parse): Add decl before use.
kono
parents:
diff changeset
3263 (reduce_count): Only define #ifdef GATHER_STATISTICS && REDUCE_LENGTH.
kono
parents:
diff changeset
3264 (current_unit_{name, language}): Delete unused vars.
kono
parents:
diff changeset
3265 (check_newline): Don't bother setting them, just accept the #pragma.
kono
parents:
diff changeset
3266 * cp-tree.h (init_repo, peek_yylex): Add prototypes.
kono
parents:
diff changeset
3267 (current_unit_{name, language}): Delete decls.
kono
parents:
diff changeset
3268
kono
parents:
diff changeset
3269 * search.c: Wrap all of the memoized functions, macros, and
kono
parents:
diff changeset
3270 variables inside #ifdef GATHER_STATISTICS.
kono
parents:
diff changeset
3271 (lookup_field, lookup_fnfields): Likewise.
kono
parents:
diff changeset
3272 (init_search_processing): Likewise.
kono
parents:
diff changeset
3273 (reinit_search_statistics): Wrap whole function.
kono
parents:
diff changeset
3274 * lex.c (reinit_lang_specific): Wrap call to reinit_search_statistics.
kono
parents:
diff changeset
3275
kono
parents:
diff changeset
3276 * decl.c (finish_function): Only call pop_memoized_context if
kono
parents:
diff changeset
3277 GATHER_STATISTICS is defined.
kono
parents:
diff changeset
3278 (start_function): Likewise for push_memoized_context.
kono
parents:
diff changeset
3279 * class.c (pushclass, popclass): Likewise.
kono
parents:
diff changeset
3280
kono
parents:
diff changeset
3281 * cp-tree.h (CLASSTYPE_MTABLE_ENTRY): Move definition from here...
kono
parents:
diff changeset
3282 * search.c (CLASSTYPE_MTABLE_ENTRY): ... to here.
kono
parents:
diff changeset
3283
kono
parents:
diff changeset
3284 * cvt.c (cp_convert): Delete unused local var FORM.
kono
parents:
diff changeset
3285 * cp-tree.h (can_convert, can_convert_arg, real_lvalue_p): Add
kono
parents:
diff changeset
3286 prototypes.
kono
parents:
diff changeset
3287
kono
parents:
diff changeset
3288 Thu Feb 22 13:19:44 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3289
kono
parents:
diff changeset
3290 * pt.c (do_poplevel): Oops; really return what we get from
kono
parents:
diff changeset
3291 poplevel this time.
kono
parents:
diff changeset
3292
kono
parents:
diff changeset
3293 Thu Feb 22 11:41:44 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3294
kono
parents:
diff changeset
3295 * cp-tree.h (is_aggr_type): Add prototype.
kono
parents:
diff changeset
3296
kono
parents:
diff changeset
3297 * cp-tree.h ({push,pop}_cp_function_context): Add decls.
kono
parents:
diff changeset
3298 * method.c ({push,pop}_cp_function_context): Delete decls.
kono
parents:
diff changeset
3299 * except.c (start_eh_unwinder, end_eh_unwinder): Declare as void.
kono
parents:
diff changeset
3300 (SetUnexpected, SetTerminate): Delete unused vars.
kono
parents:
diff changeset
3301 (init_exception_processing): Don't set SetUnexpected or
kono
parents:
diff changeset
3302 SetTerminate. Don't set SET_UNEXPECTED_FNDECL or SET_TERMINATE_FNDECL.
kono
parents:
diff changeset
3303 (output_exception_table_entry): Delete unused array LABEL.
kono
parents:
diff changeset
3304 (expand_internal_throw): Delete unused var PARAMS.
kono
parents:
diff changeset
3305 (expand_start_catch_block): Delete unused var CLEANUP.
kono
parents:
diff changeset
3306 (emit_exception_table): Delete unused var EH_NODE_DECL.
kono
parents:
diff changeset
3307 (expand_builtin_throw): Delete unused vars UNWIND_AND_THROW and
kono
parents:
diff changeset
3308 GOTO_UNWIND_AND_THROW. Don't set them.
kono
parents:
diff changeset
3309 (end_eh_unwinder): Add top decl.
kono
parents:
diff changeset
3310 (pop_rtl_from_perm): Delete unused decl of PERMANENT_OBSTACK.
kono
parents:
diff changeset
3311 (exception_section, push_rtl_perm, do_function_call,
kono
parents:
diff changeset
3312 lang_interim_eh, push_eh_cleanup, eh_outer_context,
kono
parents:
diff changeset
3313 expand_end_eh_spec, end_eh_unwinder): Declare as static.
kono
parents:
diff changeset
3314 (saved_pc, saved_throw_type, saved_throw_value, saved_cleanup,
kono
parents:
diff changeset
3315 throw_used): Likewise.
kono
parents:
diff changeset
3316 * cp-tree.h (expand_end_eh_spec): Delete prototype.
kono
parents:
diff changeset
3317
kono
parents:
diff changeset
3318 * search.c (dfs_mark, dfs_mark_vtable_path,
kono
parents:
diff changeset
3319 dfs_unmark_vtable_path, dfs_mark_new_vtable,
kono
parents:
diff changeset
3320 dfs_unmark_new_vtable, dfs_clear_search_slot,
kono
parents:
diff changeset
3321 dfs_search_slot_nonempty_p, bfs_markedp, bfs_unmarkedp,
kono
parents:
diff changeset
3322 bfs_marked_vtable_pathp, bfs_unmarked_vtable_pathp,
kono
parents:
diff changeset
3323 bfs_marked_new_vtablep, bfs_unmarked_new_vtablep): #if 0 unused
kono
parents:
diff changeset
3324 functions.
kono
parents:
diff changeset
3325 (n_fields_searched, n_calls_lookup_field, n_calls_lookup_field_1,
kono
parents:
diff changeset
3326 n_calls_lookup_fnfields, n_calls_lookup_fnfields_1,
kono
parents:
diff changeset
3327 n_calls_get_base_type, n_outer_fields_searched, n_contexts_saved):
kono
parents:
diff changeset
3328 Only define #ifdef GATHER_STATISTICS.
kono
parents:
diff changeset
3329 (reinit_search_statistics): Only init some vars if GATHER_STATISTICS
kono
parents:
diff changeset
3330 is defined.
kono
parents:
diff changeset
3331 (vbase_decl): Delete var definition.
kono
parents:
diff changeset
3332 (init_search): Delete old decl.
kono
parents:
diff changeset
3333 (init_vbase_pointers): Delete building of VBASE_DECL, since it's
kono
parents:
diff changeset
3334 never actually used.
kono
parents:
diff changeset
3335 (expand_indirect_vtbls_init): Delete init of VBASE_DECL.
kono
parents:
diff changeset
3336 (get_base_distance_recursive): Delete unused fourth arg
kono
parents:
diff changeset
3337 BASETYPE_PATH. Fix call .
kono
parents:
diff changeset
3338 (get_base_distance): Fix call.
kono
parents:
diff changeset
3339 (push_class_decls): Delete unused var ID.
kono
parents:
diff changeset
3340 (make_memoized_table_entry): Declare as static.
kono
parents:
diff changeset
3341 (breadth_first_search): Declare as static.
kono
parents:
diff changeset
3342 (tree_has_any_destructor_p): Declare as static.
kono
parents:
diff changeset
3343 (pop_class_decls): Delete unused arg pop_class_decls.
kono
parents:
diff changeset
3344 * class.c (popclass): Fix call to pop_class_decls.
kono
parents:
diff changeset
3345 * cp-tree.h (make_memoized_table_entry, breadth_first_search,
kono
parents:
diff changeset
3346 tree_has_any_destructor_p): Delete prototypes.
kono
parents:
diff changeset
3347
kono
parents:
diff changeset
3348 * rtti.c (build_ptmf_desc): Delete unused arg TYPE.
kono
parents:
diff changeset
3349 (build_t_desc): Fix call. Delete unused vars ELEMS and TT.
kono
parents:
diff changeset
3350 (build_dynamic_cast): Delete unused local vars TMP1 and RETVAL.
kono
parents:
diff changeset
3351 (build_user_desc): Delete unused var T.
kono
parents:
diff changeset
3352 (build_class_desc): Delete unused vars T and OFF.
kono
parents:
diff changeset
3353 (build_t_desc): Delete unused var NAME_STRING.
kono
parents:
diff changeset
3354 (build_headof): Make static.
kono
parents:
diff changeset
3355 (get_bad_cast_node): Likewise.
kono
parents:
diff changeset
3356 (get_def_to_follow): Likewise.
kono
parents:
diff changeset
3357 * cp-tree.h (init_type_desc): Add prototype.
kono
parents:
diff changeset
3358 (build_headof): Remove prototype.
kono
parents:
diff changeset
3359
kono
parents:
diff changeset
3360 Thu Feb 22 00:54:22 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3361
kono
parents:
diff changeset
3362 * pt.c (tsubst): Only look for matching decls at file scope for
kono
parents:
diff changeset
3363 non-member functions.
kono
parents:
diff changeset
3364
kono
parents:
diff changeset
3365 * call.c (build_scoped_method_call): Handle scoped destructor
kono
parents:
diff changeset
3366 calls in templates.
kono
parents:
diff changeset
3367
kono
parents:
diff changeset
3368 * decl.c (*_top_level): Also save previous_class_values.
kono
parents:
diff changeset
3369
kono
parents:
diff changeset
3370 * pt.c (tsubst_expr): Support do {} while loops.
kono
parents:
diff changeset
3371 * parse.y (simple_stmt): Likewise.
kono
parents:
diff changeset
3372 * tree.def: Likewise.
kono
parents:
diff changeset
3373
kono
parents:
diff changeset
3374 * method.c (build_overload_identifier): For a class nested in a
kono
parents:
diff changeset
3375 template class, don't mangle in the template parms from our
kono
parents:
diff changeset
3376 context.
kono
parents:
diff changeset
3377
kono
parents:
diff changeset
3378 * lex.c, cp-tree.h: Remove support for template instantiations in
kono
parents:
diff changeset
3379 the pending_inlines code.
kono
parents:
diff changeset
3380 * pt.c: Remove dead functions and unused arguments.
kono
parents:
diff changeset
3381 (uses_template_parms): TYPENAME_TYPEs always use template parms.
kono
parents:
diff changeset
3382 * parse.y: Stop passing anything to end_template_decl.
kono
parents:
diff changeset
3383 * tree.c (print_lang_statistics): Only print tinst info #ifdef
kono
parents:
diff changeset
3384 GATHER_STATISTICS.
kono
parents:
diff changeset
3385
kono
parents:
diff changeset
3386 Wed Feb 21 16:57:33 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3387
kono
parents:
diff changeset
3388 * init.c (expand_recursive_init{,_1}): Delete decls.
kono
parents:
diff changeset
3389 (sort_member_init): Delete unused var INIT.
kono
parents:
diff changeset
3390 (emit_base_init): Delete unused var X.
kono
parents:
diff changeset
3391 (build_offset_ref): Delete unused var CNAME.
kono
parents:
diff changeset
3392 (sort_member_init): Delete unused var FIELDS_TO_UNMARK.
kono
parents:
diff changeset
3393 (emit_base_init): Delete unused local var BASE. Delete extern
kono
parents:
diff changeset
3394 decl of IN_CHARGE_IDENTIFIER.
kono
parents:
diff changeset
3395 (build_delete): Delete unused local var VIRTUAL_SIZE.
kono
parents:
diff changeset
3396
kono
parents:
diff changeset
3397 * init.c (build_vec_delete): Delete unused third arg ELT_SIZE.
kono
parents:
diff changeset
3398 (build_delete): Fix call.
kono
parents:
diff changeset
3399 * decl2.c (delete_sanity): Likewise.
kono
parents:
diff changeset
3400 * cp-tree.h (build_vec_delete): Update prototype.
kono
parents:
diff changeset
3401
kono
parents:
diff changeset
3402 * typeck.c (common_base_type): Delete unused var TMP.
kono
parents:
diff changeset
3403 (build_binary_op): Delete local var ARGS_SAVE.
kono
parents:
diff changeset
3404 (build_array_ref): Delete unused var ITYPE.
kono
parents:
diff changeset
3405 (c_expand_return): Delete unused var USE_TEMP.
kono
parents:
diff changeset
3406
kono
parents:
diff changeset
3407 * typeck.c (compexcepttypes): Delete unused arg STRICT.
kono
parents:
diff changeset
3408 (comptypes): Fix calls.
kono
parents:
diff changeset
3409 * decl.c (duplicate_decls): Likewise.
kono
parents:
diff changeset
3410 * cp-tree.h (compexcepttypes): Delete extra arg.
kono
parents:
diff changeset
3411
kono
parents:
diff changeset
3412 * decl2.c (check_classfn): Delete unused second arg CNAME.
kono
parents:
diff changeset
3413 * decl.c (start_decl, grokfndecl): Fix calls.
kono
parents:
diff changeset
3414 * init.c (do_friend): Likewise.
kono
parents:
diff changeset
3415 * cp-tree.h (check_classfn): Update prototype.
kono
parents:
diff changeset
3416
kono
parents:
diff changeset
3417 * cp-tree.h (signature_error, import_export_vtable,
kono
parents:
diff changeset
3418 append_signature_fields, id_in_current_class, mark_used,
kono
parents:
diff changeset
3419 copy_assignment_arg_p): Add decls.
kono
parents:
diff changeset
3420 * decl2.c (mark_used): Delete decl.
kono
parents:
diff changeset
3421
kono
parents:
diff changeset
3422 * class.c (n_*): Wrap with #ifdef GATHER_STATISTICS.
kono
parents:
diff changeset
3423
kono
parents:
diff changeset
3424 * class.c (get_vtable_entry): Disable unused function.
kono
parents:
diff changeset
3425 (doing_hard_virtuals): Delete unused static global var.
kono
parents:
diff changeset
3426 (finish_struct_1): Don't init DOING_HARD_VIRTUALS.
kono
parents:
diff changeset
3427 (prepare_fresh_vtable): Delete unused vars PATH and RESULT.
kono
parents:
diff changeset
3428 (overrides): Delete unused vars RETTYPE and BASE_RETTYPE.
kono
parents:
diff changeset
3429 (modify_one_vtable): Delete unused var OLD_RTTI.
kono
parents:
diff changeset
3430 (finish_struct_anon): Delete unused vars OFFSET and X.
kono
parents:
diff changeset
3431 (finish_struct_bits): Delete unused var METHOD_VEC.
kono
parents:
diff changeset
3432 (get_basefndecls): Delete unused var PURPOSE. Delete unused
kono
parents:
diff changeset
3433 for-scope local variable METHODS.
kono
parents:
diff changeset
3434
kono
parents:
diff changeset
3435 * call.c (user_harshness): Delete unused/unneeded arg PARM.
kono
parents:
diff changeset
3436 (ideal_candidate): Delete unused args BASETYPE and PARMS.
kono
parents:
diff changeset
3437 (build_method_call): Delete unused args passed into ideal_candidate.
kono
parents:
diff changeset
3438 (build_overload_call_real): Likewise. Delete unused var OVERLOAD_NAME.
kono
parents:
diff changeset
3439 * cp-tree.h (synthesize_method): Add decl.
kono
parents:
diff changeset
3440
kono
parents:
diff changeset
3441 * decl.c (note_level_for_for): Give void return type.
kono
parents:
diff changeset
3442 (pushdecl_nonclass_level): Likewise.
kono
parents:
diff changeset
3443 (finish_function): Delete unused vars VFIELDS and ALLOCATED_THIS.
kono
parents:
diff changeset
3444 (poplevel): Delete unused var IMPLICIT_TRY_BLOCK.
kono
parents:
diff changeset
3445 (suspend_binding_level): Delete unused var LEVEL.
kono
parents:
diff changeset
3446 (duplicate_decls): Delete unused var CTYPE.
kono
parents:
diff changeset
3447 (duplicate_decls): Delete unused var PREVIOUS_C_DECL.
kono
parents:
diff changeset
3448 (init_decl_processing): Delete unused vars FLOAT_ENDLINK and
kono
parents:
diff changeset
3449 PTR_ENDLINK.
kono
parents:
diff changeset
3450 (grokdeclarator): Delete unused var C.
kono
parents:
diff changeset
3451 (grokdeclarator): Delete unused var SIZE_VARIES.
kono
parents:
diff changeset
3452 (grokparms): Delete unused var SAW_VOID.
kono
parents:
diff changeset
3453 (start_function): Delete unused var OLDDECL.
kono
parents:
diff changeset
3454 (cplus_expand_expr_stmt): Delete unused var
kono
parents:
diff changeset
3455 REMOVE_IMPLICIT_IMMEDIATELY.
kono
parents:
diff changeset
3456
kono
parents:
diff changeset
3457 * cp-tree.h (pushdecl_nonclass_level): Fix prototype.
kono
parents:
diff changeset
3458
kono
parents:
diff changeset
3459 * Makefile.in (CONFLICTS): Update to 12 shift/reduce.
kono
parents:
diff changeset
3460
kono
parents:
diff changeset
3461 Wed Feb 21 00:06:17 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3462
kono
parents:
diff changeset
3463 * tree.c (build_min): Set TREE_COMPLEXITY to lineno.
kono
parents:
diff changeset
3464 (build_min_nt): Likewise.
kono
parents:
diff changeset
3465 * pt.c (do_pushlevel): Emit line note.
kono
parents:
diff changeset
3466 (do_poplevel): Return what we get from poplevel.
kono
parents:
diff changeset
3467 (tsubst_expr): Set lineno from TREE_COMPLEXITY in stmt nodes.
kono
parents:
diff changeset
3468 * parse.y: Use do_pushlevel and do_poplevel.
kono
parents:
diff changeset
3469 * cp-tree.h: Declare do_poplevel.
kono
parents:
diff changeset
3470
kono
parents:
diff changeset
3471 * cp-tree.h: Declare at_eof.
kono
parents:
diff changeset
3472 * decl.c (cp_finish_decl): Pass it to rest_of_decl_compilation.
kono
parents:
diff changeset
3473 * decl2.c (import_export_decl): Renamed from import_export_inline.
kono
parents:
diff changeset
3474 (finish_file): Call it to do interface handling for statics.
kono
parents:
diff changeset
3475 * pt.c (tsubst_copy): Call mark_used on variables and functions
kono
parents:
diff changeset
3476 used here.
kono
parents:
diff changeset
3477
kono
parents:
diff changeset
3478 * decl2.c (finish_file): Don't emit statics we can't generate.
kono
parents:
diff changeset
3479 * pt.c (instantiate_decl): Don't set interface on instantiations
kono
parents:
diff changeset
3480 we can't generate.
kono
parents:
diff changeset
3481
kono
parents:
diff changeset
3482 * cp-tree.h (struct tinst_level): Change 'classname' to 'decl'.
kono
parents:
diff changeset
3483 * tree.c (print_lang_statistics): Print max template depth.
kono
parents:
diff changeset
3484 * pt.c (push_tinst_level): Dump entire instantiation context.
kono
parents:
diff changeset
3485 (instantiate_class_template): Use it and pop_tinst_level.
kono
parents:
diff changeset
3486 (instantiate_decl): Likewise.
kono
parents:
diff changeset
3487
kono
parents:
diff changeset
3488 * call.c class.c cp-tree.h decl.c decl2.c error.c lex.c method.c
kono
parents:
diff changeset
3489 pt.c ptree.c tree.def: Remove all traces of UNINSTANTIATED_P_TYPE.
kono
parents:
diff changeset
3490
kono
parents:
diff changeset
3491 Tue Feb 20 18:21:51 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3492
kono
parents:
diff changeset
3493 * call.c class.c cp-tree.h cvt.c decl.c decl2.c error.c expr.c
kono
parents:
diff changeset
3494 init.c lex.c method.c parse.y pt.c repo.c search.c spew.c tree.c
kono
parents:
diff changeset
3495 tree.def typeck.c typeck2.c xref.c: Massive, systemic changes for
kono
parents:
diff changeset
3496 the new template implementation.
kono
parents:
diff changeset
3497
kono
parents:
diff changeset
3498 Tue Feb 20 17:14:29 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3499
kono
parents:
diff changeset
3500 * decl2.c (check_cp_case_value): Use STRIP_TYPE_NOPS.
kono
parents:
diff changeset
3501
kono
parents:
diff changeset
3502 Thu Feb 15 18:44:42 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3503
kono
parents:
diff changeset
3504 * decl.c (cp_finish_decl): Delay emitting the debug information for
kono
parents:
diff changeset
3505 a typedef that has been installed as the canonical typedef, if the
kono
parents:
diff changeset
3506 type has not yet been defined.
kono
parents:
diff changeset
3507
kono
parents:
diff changeset
3508 Thu Feb 15 09:39:08 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3509
kono
parents:
diff changeset
3510 * decl2.c (grokfield): Still call pop_nested_class for access decls.
kono
parents:
diff changeset
3511
kono
parents:
diff changeset
3512 Wed Feb 14 17:30:04 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3513
kono
parents:
diff changeset
3514 * decl.c (lookup_label): Call label_rtx.
kono
parents:
diff changeset
3515
kono
parents:
diff changeset
3516 * decl.c (make_binding_level): New function.
kono
parents:
diff changeset
3517 (pushlevel, pushlevel_class): Call it instead of explicit
kono
parents:
diff changeset
3518 duplicate calls to xmalloc.
kono
parents:
diff changeset
3519
kono
parents:
diff changeset
3520 * decl.c (init_decl_processing): Delete useless build_pointer_type
kono
parents:
diff changeset
3521 call.
kono
parents:
diff changeset
3522
kono
parents:
diff changeset
3523 * decl.c (float_ftype_float, ldouble_ftype_ldouble): Add definitions.
kono
parents:
diff changeset
3524 (sizet_ftype_string): Delete variable.
kono
parents:
diff changeset
3525 (init_decl_processing): Add built-in functions fabsf, fabsl,
kono
parents:
diff changeset
3526 sqrtf, sqrtl, sinf, sin, sinl, cosf, cos, cosl. New local
kono
parents:
diff changeset
3527 variable strlen_ftype, used for strlen.
kono
parents:
diff changeset
3528
kono
parents:
diff changeset
3529 Wed Feb 14 16:21:25 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3530
kono
parents:
diff changeset
3531 * decl.c (push_to_top_level): Start from current_binding_level
kono
parents:
diff changeset
3532 again for now; the stl hacks depend on g++ being broken in this
kono
parents:
diff changeset
3533 way, and it'll be fixed in the template rewrite.
kono
parents:
diff changeset
3534
kono
parents:
diff changeset
3535 * tree.def: Add USING_DECL.
kono
parents:
diff changeset
3536 * decl2.c (do_class_using_decl): Implement.
kono
parents:
diff changeset
3537 (grokfield): Pass access decls off to do_class_using_decl instead of
kono
parents:
diff changeset
3538 grokdeclarator.
kono
parents:
diff changeset
3539 * error.c (dump_decl): Handle USING_DECLs.
kono
parents:
diff changeset
3540 * decl.c (grokdeclarator): Remove code for handling access decls.
kono
parents:
diff changeset
3541 * class.c (finish_struct_1): Adjust accordingly, treat using-decls
kono
parents:
diff changeset
3542 as access decls for now.
kono
parents:
diff changeset
3543 (finish_struct): Don't check USING_DECLs for other uses of the name.
kono
parents:
diff changeset
3544
kono
parents:
diff changeset
3545 * search.c (get_matching_virtual): Use cp_error_at.
kono
parents:
diff changeset
3546
kono
parents:
diff changeset
3547 Wed Feb 14 10:36:58 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3548
kono
parents:
diff changeset
3549 * typeck.c (comptypes): Default COMP_TYPE_ATTRIBUTES to 1, to
kono
parents:
diff changeset
3550 match c-typeck.c.
kono
parents:
diff changeset
3551 (self_promoting_args_p): Move the check that TYPE is non-nil
kono
parents:
diff changeset
3552 before trying to look at its main variant.
kono
parents:
diff changeset
3553 (unsigned_type, signed_type): Add checking of DI/SI/HI/QI nodes.
kono
parents:
diff changeset
3554
kono
parents:
diff changeset
3555 * cp-tree.h (DECL_WAITING_FRIENDS, SET_DECL_WAITING_FRIENDS):
kono
parents:
diff changeset
3556 Delete macros.
kono
parents:
diff changeset
3557 * init.c (xref_friend, embrace_waiting_friends): Delete functions.
kono
parents:
diff changeset
3558 (do_friend): Delete call to xref_friend.
kono
parents:
diff changeset
3559 * class.c (finish_struct_1): Delete call to embrace_waiting_friends.
kono
parents:
diff changeset
3560
kono
parents:
diff changeset
3561 * typeck.c (convert_sequence): #if 0 unused function.
kono
parents:
diff changeset
3562
kono
parents:
diff changeset
3563 * cp-tree.h (DECL_IN_MEMORY_P): New macro w/ the check that used to
kono
parents:
diff changeset
3564 be in decl_in_memory_p.
kono
parents:
diff changeset
3565 (decl_in_memory_p): Delete decl.
kono
parents:
diff changeset
3566 * expr.c (decl_in_memory_p): Delete fn.
kono
parents:
diff changeset
3567 * typeck.c (mark_addressable): Use DECL_IN_MEMORY_P.
kono
parents:
diff changeset
3568
kono
parents:
diff changeset
3569 * decl.c (cp_finish_decl): Use DECL_IN_MEMORY_P.
kono
parents:
diff changeset
3570
kono
parents:
diff changeset
3571 Tue Feb 13 12:51:21 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3572
kono
parents:
diff changeset
3573 * class.c (finish_struct_1): Check for a pure-specifier on a
kono
parents:
diff changeset
3574 non-virtual function here.
kono
parents:
diff changeset
3575
kono
parents:
diff changeset
3576 * decl2.c (grok_function_init): Don't check whether the function
kono
parents:
diff changeset
3577 is virtual here.
kono
parents:
diff changeset
3578 (grokfield): Don't call check_for_override here.
kono
parents:
diff changeset
3579
kono
parents:
diff changeset
3580 * decl.c (push_to_top_level): Start from inner_binding_level,
kono
parents:
diff changeset
3581 check class_shadowed in class levels.
kono
parents:
diff changeset
3582
kono
parents:
diff changeset
3583 Mon Feb 12 17:46:59 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3584
kono
parents:
diff changeset
3585 * decl.c (resume_level): Ignore things that don't have names, instead
kono
parents:
diff changeset
3586 of core dumping.
kono
parents:
diff changeset
3587
kono
parents:
diff changeset
3588 Mon Feb 12 15:47:44 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3589
kono
parents:
diff changeset
3590 * decl2.c (grokfield): Set DECL_VINDEX properly for FUNCTION_DECLs.
kono
parents:
diff changeset
3591
kono
parents:
diff changeset
3592 Sat Feb 10 17:59:45 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3593
kono
parents:
diff changeset
3594 * class.c (finish_struct_1): Set DECL_VINDEX properly on a
kono
parents:
diff changeset
3595 synthesized dtor.
kono
parents:
diff changeset
3596
kono
parents:
diff changeset
3597 * parse.y (complete_type_name): Bind global_scope earlier.
kono
parents:
diff changeset
3598 (complex_type_name): Likewise.
kono
parents:
diff changeset
3599 (qualified_type_name): Remove.
kono
parents:
diff changeset
3600
kono
parents:
diff changeset
3601 Thu Feb 8 15:15:14 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3602
kono
parents:
diff changeset
3603 * decl.c (grokfndecl): Move code that looks for virtuals in base
kono
parents:
diff changeset
3604 classes...
kono
parents:
diff changeset
3605 * class.c (check_for_override): ... to a new function.
kono
parents:
diff changeset
3606 (finish_struct_1): Call it.
kono
parents:
diff changeset
3607
kono
parents:
diff changeset
3608 * cp-tree.h: Declare warn_sign_compare.
kono
parents:
diff changeset
3609
kono
parents:
diff changeset
3610 * typeck.c (build_binary_op_nodefault): Check warn_sign_compare
kono
parents:
diff changeset
3611 rather than extra_warnings to decide whether to warn about
kono
parents:
diff changeset
3612 comparison of signed and unsigned.
kono
parents:
diff changeset
3613
kono
parents:
diff changeset
3614 * decl2.c (lang_decode_option): Handle warn_sign_compare. -Wall
kono
parents:
diff changeset
3615 implies -Wsign-compare. -Wall doesn't imply -W.
kono
parents:
diff changeset
3616
kono
parents:
diff changeset
3617 Wed Feb 7 15:27:57 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3618
kono
parents:
diff changeset
3619 * typeck.c (build_component_ref): Fix to handle anon unions in base
kono
parents:
diff changeset
3620 classes as well.
kono
parents:
diff changeset
3621
kono
parents:
diff changeset
3622 Wed Feb 7 14:29:12 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3623
kono
parents:
diff changeset
3624 * class.c (resolves_to_fixed_type_p): Delete code dealing with
kono
parents:
diff changeset
3625 a WITH_CLEANUP_EXPR, since we don't generate them any more.
kono
parents:
diff changeset
3626 * cvt.c (build_up_reference): Likewise.
kono
parents:
diff changeset
3627 * decl.c (grok_reference_init): Likewise.
kono
parents:
diff changeset
3628 (cp_finish_decl): Likewise.
kono
parents:
diff changeset
3629 * error.c (dump_expr): Likewise.
kono
parents:
diff changeset
3630 * tree.c (real_lvalue_p): Likewise.
kono
parents:
diff changeset
3631 (lvalue_p): Likewise.
kono
parents:
diff changeset
3632 (build_cplus_new): Likewise.
kono
parents:
diff changeset
3633 (unsave_expr_now): Likewise.
kono
parents:
diff changeset
3634 * typeck.c (unary_complex_lvalue, build_modify_expr,
kono
parents:
diff changeset
3635 c_expand_return): Likewise.
kono
parents:
diff changeset
3636
kono
parents:
diff changeset
3637 Tue Feb 6 13:39:22 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3638
kono
parents:
diff changeset
3639 Make the C++ front-end pay attention to attributes for structures.
kono
parents:
diff changeset
3640 * class.c (finish_struct): New argument ATTRIBUTES, passed down into
kono
parents:
diff changeset
3641 finish_struct_1.
kono
parents:
diff changeset
3642 (finish_struct_1): New argument ATTRIBUTES; call cplus_decl_attributes.
kono
parents:
diff changeset
3643 Take out old round_up_size use and setting the DECL_ALIGN possibly
kono
parents:
diff changeset
3644 using it. Take out setting of TYPE_ALIGN to round_up_size, which
kono
parents:
diff changeset
3645 can override what the attribute set.
kono
parents:
diff changeset
3646 * cp-tree.h (finish_struct): Update prototype.
kono
parents:
diff changeset
3647 * parse.y (template_instantiate_once): Pass a NULL_TREE for the
kono
parents:
diff changeset
3648 attributes to finish_struct.
kono
parents:
diff changeset
3649 (structsp): For a CLASS decl, add maybe_attribute to rule and pass that
kono
parents:
diff changeset
3650 value down into finish_struct.
kono
parents:
diff changeset
3651 * Makefile.in (CONFLICTS): Switch to 7 shift/reduce conflicts.
kono
parents:
diff changeset
3652
kono
parents:
diff changeset
3653 Tue Feb 6 13:12:15 1996 Per Bothner <bothner@kalessin.cygnus.com>
kono
parents:
diff changeset
3654
kono
parents:
diff changeset
3655 * decl.c (poplevel): Re-word dead for local handling.
kono
parents:
diff changeset
3656 (pushdecl): Remove useless DECL_DEAD_FOR_LOCAL test.
kono
parents:
diff changeset
3657 (cp_finish_decl): If is_for_scope, check for duplicates so
kono
parents:
diff changeset
3658 we can disable is_for_scope. Otherwise, preserve_temp_slots.
kono
parents:
diff changeset
3659
kono
parents:
diff changeset
3660 * lex.c (do_identifier): Use global binding in preference of
kono
parents:
diff changeset
3661 dead for local variable.
kono
parents:
diff changeset
3662
kono
parents:
diff changeset
3663 Mon Feb 5 17:46:46 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3664
kono
parents:
diff changeset
3665 * init.c (initializing_context): Handle anon union changes, the
kono
parents:
diff changeset
3666 context where fields of anon unions can be initialized now has to be
kono
parents:
diff changeset
3667 found by walking up the TYPE_CONTEXT chain.
kono
parents:
diff changeset
3668
kono
parents:
diff changeset
3669 Fri Feb 2 14:54:04 1996 Doug Evans <dje@charmed.cygnus.com>
kono
parents:
diff changeset
3670
kono
parents:
diff changeset
3671 * decl.c (start_decl): #ifdef out code to set DECL_COMMON
kono
parents:
diff changeset
3672 if ASM_OUTPUT{,_ALIGNED}_BSS is defined.
kono
parents:
diff changeset
3673 (obscure_complex_init): If bss is supported, always set
kono
parents:
diff changeset
3674 DECL_INITIAL to error_mark_node.
kono
parents:
diff changeset
3675
kono
parents:
diff changeset
3676 Thu Feb 1 16:19:56 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3677
kono
parents:
diff changeset
3678 * init.c (is_friend): Make sure there's a context before we see if
kono
parents:
diff changeset
3679 it's an aggr type.
kono
parents:
diff changeset
3680
kono
parents:
diff changeset
3681 Thu Feb 1 15:44:53 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3682
kono
parents:
diff changeset
3683 * init.c (is_friend): Classes are not friendly with nested classes.
kono
parents:
diff changeset
3684
kono
parents:
diff changeset
3685 Thu Feb 1 15:27:37 1996 Doug Evans <dje@charmed.cygnus.com>
kono
parents:
diff changeset
3686
kono
parents:
diff changeset
3687 * lex.c (check_newline): Pass last character read to HANDLE_PRAGMA,
kono
parents:
diff changeset
3688 and record its result.
kono
parents:
diff changeset
3689
kono
parents:
diff changeset
3690 Thu Feb 1 09:27:01 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3691
kono
parents:
diff changeset
3692 * class.c (finish_struct_anon): Switch around code to not move anon
kono
parents:
diff changeset
3693 union elements around, nor mess up their contexts, nor offsets,
kono
parents:
diff changeset
3694 instead we now build up the right number of COMPONENT_REFs for all
kono
parents:
diff changeset
3695 the anon unions that may be present at build_component_ref time.
kono
parents:
diff changeset
3696 * typeck.c (lookup_anon_field): New routine to handle field lookup
kono
parents:
diff changeset
3697 on fields without names. We find them, based upon their unique type
kono
parents:
diff changeset
3698 instead.
kono
parents:
diff changeset
3699 * typeck.c (build_component_ref): Allow FIELD_DECL components.
kono
parents:
diff changeset
3700 Handle finding components in anonymous unions, and ensure that a
kono
parents:
diff changeset
3701 COMPONENT_REF is built for each level as necessary.
kono
parents:
diff changeset
3702
kono
parents:
diff changeset
3703 Tue Jan 30 18:18:23 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3704
kono
parents:
diff changeset
3705 * cvt.c (build_up_reference): Make the INDIRECT_BIND case come after
kono
parents:
diff changeset
3706 code that ensures that copy ctors are used if appropriate.
kono
parents:
diff changeset
3707
kono
parents:
diff changeset
3708 Tue Jan 30 17:35:14 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3709
kono
parents:
diff changeset
3710 * init.c (build_vec_delete): Only give an error if base isn't an
kono
parents:
diff changeset
3711 error_mark_node.
kono
parents:
diff changeset
3712
kono
parents:
diff changeset
3713 Mon Jan 29 17:09:06 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3714
kono
parents:
diff changeset
3715 * spew.c (do_aggr): `new struct S;' isn't a forward declaration.
kono
parents:
diff changeset
3716 (yylex): If we see `new', keep slurping.
kono
parents:
diff changeset
3717
kono
parents:
diff changeset
3718 Thu Jan 25 18:31:36 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3719
kono
parents:
diff changeset
3720 * class.c (finish_struct_1): Move code for handling anon unions...
kono
parents:
diff changeset
3721 (finish_struct_anon): to here. Fixup so that we do the offset
kono
parents:
diff changeset
3722 calculations right, and so that the fields are physically moved to
kono
parents:
diff changeset
3723 the containers's chain.
kono
parents:
diff changeset
3724
kono
parents:
diff changeset
3725 Thu Jan 25 18:27:37 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3726
kono
parents:
diff changeset
3727 * decl.c (grokdeclarator): Avoid trying to get an operand off an
kono
parents:
diff changeset
3728 identifier node.
kono
parents:
diff changeset
3729
kono
parents:
diff changeset
3730 Wed Jan 24 11:25:30 1996 Jim Wilson <wilson@chestnut.cygnus.com>
kono
parents:
diff changeset
3731
kono
parents:
diff changeset
3732 * typeck.c (pointer_int_sum): Use TYPE_PRECISION (sizetype) not
kono
parents:
diff changeset
3733 POINTER_SIZE to agree with expr.c.
kono
parents:
diff changeset
3734
kono
parents:
diff changeset
3735 Thu Jan 25 13:01:23 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3736
kono
parents:
diff changeset
3737 * search.c (lookup_field): Don't report ambiguities if protect is 0,
kono
parents:
diff changeset
3738 instead return NULL_TREE.
kono
parents:
diff changeset
3739
kono
parents:
diff changeset
3740 Wed Jan 24 13:01:26 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3741
kono
parents:
diff changeset
3742 * class.c (finish_struct_1): Call warn_hidden if we want warnings
kono
parents:
diff changeset
3743 about overloaded virtual functions.
kono
parents:
diff changeset
3744 (warn_hidden): New routine to warn of virtual functions that are
kono
parents:
diff changeset
3745 hidden by other virtual functions, that are not overridden.
kono
parents:
diff changeset
3746 (get_basefndecls): New routine, used by warn_hidden.
kono
parents:
diff changeset
3747 (mark_overriders): New routine, used by warn_hidden.
kono
parents:
diff changeset
3748 * search.c (get_matching_virtual): Remove old warning that just
kono
parents:
diff changeset
3749 isn't very useful.
kono
parents:
diff changeset
3750
kono
parents:
diff changeset
3751 Tue Jan 23 12:26:10 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3752
kono
parents:
diff changeset
3753 * decl.c (output_builtin_tdesc_entries): #if 0 the function definition.
kono
parents:
diff changeset
3754
kono
parents:
diff changeset
3755 * typeck.c (null_ptr_cst_p): Delete unused fn.
kono
parents:
diff changeset
3756 (build_function_call_maybe): Delete unused fn.
kono
parents:
diff changeset
3757
kono
parents:
diff changeset
3758 * expr.c (extract_init): #if 0 the code after unconditional return 0
kono
parents:
diff changeset
3759 for now.
kono
parents:
diff changeset
3760
kono
parents:
diff changeset
3761 Delete old cadillac code.
kono
parents:
diff changeset
3762 * edsel.c: Remove file.
kono
parents:
diff changeset
3763 * Make-lang.in (CXX_SRCS): Take edsel.c off the list.
kono
parents:
diff changeset
3764 * Makefile.in (CXX_OBJS): Delete edsel.o.
kono
parents:
diff changeset
3765 (edsel.o): Delete rule.
kono
parents:
diff changeset
3766 * cp-tree.h (flag_cadillac): Delete var decl.
kono
parents:
diff changeset
3767 * lang-options.h: Delete "-fcadillac" and "-fno-cadillac".
kono
parents:
diff changeset
3768 * decl2.c (flag_cadillac): Delete var definition.
kono
parents:
diff changeset
3769 (lang_decode_option): Delete handling of -fcadillac and -fno-cadillac.
kono
parents:
diff changeset
3770 (grokfield): Delete code depending on flag_cadillac.
kono
parents:
diff changeset
3771 (finish_anon_union): Likewise.
kono
parents:
diff changeset
3772 * class.c (finish_struct_1): Likewise.
kono
parents:
diff changeset
3773 (pushclass): Likewise.
kono
parents:
diff changeset
3774 (popclass): Likewise.
kono
parents:
diff changeset
3775 (push_lang_context): Likewise.
kono
parents:
diff changeset
3776 (pop_lang_context): Likewise.
kono
parents:
diff changeset
3777 * decl.c (init_decl_processing): Likewise.
kono
parents:
diff changeset
3778 (start_decl): Likewise.
kono
parents:
diff changeset
3779 (cp_finish_decl): Likewise.
kono
parents:
diff changeset
3780 (xref_tag): Likewise.
kono
parents:
diff changeset
3781 (finish_enum): Likewise.
kono
parents:
diff changeset
3782 (start_function): Likewise.
kono
parents:
diff changeset
3783 (finish_function): Likewise.
kono
parents:
diff changeset
3784 (finish_stmt): Likewise.
kono
parents:
diff changeset
3785 * lex.c (lang_init): Likewise.
kono
parents:
diff changeset
3786 (check_newline): Likewise.
kono
parents:
diff changeset
3787
kono
parents:
diff changeset
3788 * lex.c (do_pending_inlines): Delete synthesized method kludge.
kono
parents:
diff changeset
3789
kono
parents:
diff changeset
3790 Delete defunct, ancient garbage collection implementation.
kono
parents:
diff changeset
3791 * rtti.c: New file with the RTTI stuff from gc.c.
kono
parents:
diff changeset
3792 * gc.c: Removed file (moved the remaining stuff into rtti.c).
kono
parents:
diff changeset
3793 * Makefile.in (CXX_OBJS): Replace gc.o with rtti.o.
kono
parents:
diff changeset
3794 (rtti.o): New rule, replacing gc.o.
kono
parents:
diff changeset
3795 * Make-lang.in (CXX_SRCS): Replace gc.c with rtti.c.
kono
parents:
diff changeset
3796 * cp-tree.h: Delete gc-related fn decls.
kono
parents:
diff changeset
3797 (DECL_GC_OFFSET): Delete macro.
kono
parents:
diff changeset
3798 (flag_gc): Delete extern decl.
kono
parents:
diff changeset
3799 * decl.c (current_function_obstack_index): Delete var decl.
kono
parents:
diff changeset
3800 (current_function_obstack_usage): Delete var decl.
kono
parents:
diff changeset
3801 (start_function): Delete clearing of current_function_obstack_index
kono
parents:
diff changeset
3802 and current_function_obstack_usage.
kono
parents:
diff changeset
3803 (init_decl_processing): Delete code relying on -fgc.
kono
parents:
diff changeset
3804 Delete call to init_gc_processing.
kono
parents:
diff changeset
3805 (cp_finish_decl): Delete calls to build_static_gc_entry and
kono
parents:
diff changeset
3806 type_needs_gc_entry. Delete gc code setting DECL_GC_OFFSET.
kono
parents:
diff changeset
3807 (store_parm_decls): Delete -fgc calls to cp_expand_decl_cleanup
kono
parents:
diff changeset
3808 and to expand_expr of a __gc_main call.
kono
parents:
diff changeset
3809 (maybe_gc_cleanup): Delete var decl.
kono
parents:
diff changeset
3810 (finish_function): Delete call to expand_gc_prologue_and_epilogue.
kono
parents:
diff changeset
3811 * decl2.c (flag_gc): Delete var decl.
kono
parents:
diff changeset
3812 (lang_f_options): Delete offering of -fgc.
kono
parents:
diff changeset
3813 (lang_decode_option): Delete -fgc and -fno-gc handling.
kono
parents:
diff changeset
3814 (get_temp_regvar): Delete gc code.
kono
parents:
diff changeset
3815 * init.c (build_new): Delete gc code.
kono
parents:
diff changeset
3816 * lex.c (init_lex): Delete checking of flag_gc.
kono
parents:
diff changeset
3817
kono
parents:
diff changeset
3818 * typeck.c (convert_arguments): Delete gc code.
kono
parents:
diff changeset
3819 (build_component_addr): Delete -fgc warning.
kono
parents:
diff changeset
3820 (build_modify_expr): Delete gc code.
kono
parents:
diff changeset
3821
kono
parents:
diff changeset
3822 * decl2.c (build_push_scope): Delete fn.
kono
parents:
diff changeset
3823 * cp-tree.h (build_push_scope): Delete decl.
kono
parents:
diff changeset
3824
kono
parents:
diff changeset
3825 * search.c (clear_search_slots): Delete fn.
kono
parents:
diff changeset
3826 * cp-tree.h (clear_search_slots): Delete decl.
kono
parents:
diff changeset
3827
kono
parents:
diff changeset
3828 * search.c (tree_needs_constructor_p): Delete fn.
kono
parents:
diff changeset
3829 * cp-tree.h (tree_needs_constructor_p): Delete decl.
kono
parents:
diff changeset
3830
kono
parents:
diff changeset
3831 * tree.c (id_cmp): Delete fn.
kono
parents:
diff changeset
3832
kono
parents:
diff changeset
3833 * tree.c (set_fnaddr_from_vtable_entry): Delete fn.
kono
parents:
diff changeset
3834 * cp-tree.h (set_fnaddr_from_vtable_entry): Delete decl.
kono
parents:
diff changeset
3835
kono
parents:
diff changeset
3836 * tree.c (decl_value_member): Delete fn.
kono
parents:
diff changeset
3837 * cp-tree.h (decl_value_member): Delete decl.
kono
parents:
diff changeset
3838
kono
parents:
diff changeset
3839 * tree.c (list_hash_lookup_or_cons): Delete fn.
kono
parents:
diff changeset
3840 * cp-tree.h (list_hash_lookup_or_cons): Delete decl.
kono
parents:
diff changeset
3841
kono
parents:
diff changeset
3842 * method.c (cplus_exception_name): Delete fn.
kono
parents:
diff changeset
3843 (EXCEPTION_NAME_{PREFIX, LENGTH}): Delete macros.
kono
parents:
diff changeset
3844
kono
parents:
diff changeset
3845 * spew.c (shift_tokens): Delete fn.
kono
parents:
diff changeset
3846
kono
parents:
diff changeset
3847 Mon Jan 22 17:49:33 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3848
kono
parents:
diff changeset
3849 * except.c (init_exception_processing): Pass 1 to needs_pop in calls
kono
parents:
diff changeset
3850 to cp_finish_decl.
kono
parents:
diff changeset
3851 * parse.y: Likewise.
kono
parents:
diff changeset
3852
kono
parents:
diff changeset
3853 Mon Jan 22 17:34:29 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3854
kono
parents:
diff changeset
3855 * tree.c (build_cplus_staticfn_type): Delete function definition;
kono
parents:
diff changeset
3856 never used.
kono
parents:
diff changeset
3857 * cp-tree.h (build_cplus_staticfn_type): Delete decl.
kono
parents:
diff changeset
3858
kono
parents:
diff changeset
3859 * tree.c (virtual_member): Delete function definition; never used.
kono
parents:
diff changeset
3860 * cp-tree.h (virtual_member): Delete decl.
kono
parents:
diff changeset
3861
kono
parents:
diff changeset
3862 Fri Jan 19 18:03:14 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3863
kono
parents:
diff changeset
3864 * typeck.c (build_component_ref): Handle getting vbase pointers
kono
parents:
diff changeset
3865 out of complex multiple inheritance better.
kono
parents:
diff changeset
3866
kono
parents:
diff changeset
3867 Fri Jan 19 16:27:40 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3868
kono
parents:
diff changeset
3869 * typeck.c (build_object_ref): Make sure we use the real type, not
kono
parents:
diff changeset
3870 any reference type.
kono
parents:
diff changeset
3871
kono
parents:
diff changeset
3872 Fri Jan 19 16:01:47 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3873
kono
parents:
diff changeset
3874 * tree.c (build_exception_variant): Don't create new types if we
kono
parents:
diff changeset
3875 don't have to, also build new types on the right obstack.
kono
parents:
diff changeset
3876
kono
parents:
diff changeset
3877 Fri Jan 19 14:09:44 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3878
kono
parents:
diff changeset
3879 * decl.c (store_bindings): Split out from push_to_top_level.
kono
parents:
diff changeset
3880 (push_to_top_level): Call it for b->type_shadowed on class binding
kono
parents:
diff changeset
3881 levels.
kono
parents:
diff changeset
3882
kono
parents:
diff changeset
3883 Fri Jan 19 13:53:14 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3884
kono
parents:
diff changeset
3885 * search.c (expand_upcast_fixups): Fix so that offsets stored in
kono
parents:
diff changeset
3886 vbase_offsets are always right. Fixes a problem where virtual base
kono
parents:
diff changeset
3887 upcasting and downcasting could be wrong during conversions on this
kono
parents:
diff changeset
3888 during virtual function dispatch at ctor/dtor time when dynamic
kono
parents:
diff changeset
3889 vtable fixups for deltas are needed. This only sounds easier than
kono
parents:
diff changeset
3890 it is. :-)
kono
parents:
diff changeset
3891 (fixup_virtual_upcast_offsets): Change to reflect new calling
kono
parents:
diff changeset
3892 convention for expand_upcast_fixups.
kono
parents:
diff changeset
3893
kono
parents:
diff changeset
3894 Fri Jan 19 12:23:08 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3895
kono
parents:
diff changeset
3896 * decl2.c (grokbitfield): Strip the NOPs from WIDTH before we
kono
parents:
diff changeset
3897 check that it's usable as the bitfield width.
kono
parents:
diff changeset
3898
kono
parents:
diff changeset
3899 Wed Jan 17 21:22:40 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3900
kono
parents:
diff changeset
3901 * decl2.c (grokfield): Call cplus_decl_attributes with the attrlist.
kono
parents:
diff changeset
3902 Pass a null tree to grokdeclarator for its ATTRLIST arg, since it's
kono
parents:
diff changeset
3903 only ever used for functions in it.
kono
parents:
diff changeset
3904
kono
parents:
diff changeset
3905 Wed Jan 17 12:10:38 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3906
kono
parents:
diff changeset
3907 * parse.y (qualified_type_name): Use the TYPE_DECL, not the type.
kono
parents:
diff changeset
3908 (nested_type): Likewise.
kono
parents:
diff changeset
3909 (nested_name_specifier): Use lastiddecl.
kono
parents:
diff changeset
3910
kono
parents:
diff changeset
3911 * decl.c (grokdeclarator): Adjust accordingly.
kono
parents:
diff changeset
3912 * init.c (expand_member_init): Likewise.
kono
parents:
diff changeset
3913 * parse.y (base_class): Likewise.
kono
parents:
diff changeset
3914 * typeck2.c (build_functional_cast): Likewise.
kono
parents:
diff changeset
3915
kono
parents:
diff changeset
3916 * typeck2.c (build_functional_cast): Fill in name after we've
kono
parents:
diff changeset
3917 checked for non-aggr type.
kono
parents:
diff changeset
3918
kono
parents:
diff changeset
3919 Wed Jan 17 10:18:01 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3920
kono
parents:
diff changeset
3921 * decl2.c (warn_pointer_arith): Default to on.
kono
parents:
diff changeset
3922
kono
parents:
diff changeset
3923 Tue Jan 16 12:45:38 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3924
kono
parents:
diff changeset
3925 * lex.c (is_rid): New function.
kono
parents:
diff changeset
3926 * decl.c (grokdeclarator): Diagnose reserved words used as
kono
parents:
diff changeset
3927 declarator-ids.
kono
parents:
diff changeset
3928
kono
parents:
diff changeset
3929 Tue Jan 16 11:39:40 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3930
kono
parents:
diff changeset
3931 * tree.c (get_decl_list): Don't lose cv-quals.
kono
parents:
diff changeset
3932
kono
parents:
diff changeset
3933 * decl.c (grokdeclarator): Fix SCOPE_REF handling and diagnose
kono
parents:
diff changeset
3934 typespecs used as declarator-ids.
kono
parents:
diff changeset
3935
kono
parents:
diff changeset
3936 Tue Jan 16 11:09:42 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
3937
kono
parents:
diff changeset
3938 * decl.c (poplevel): When popping a level, don't give a warning for
kono
parents:
diff changeset
3939 any subblocks that already exist.
kono
parents:
diff changeset
3940
kono
parents:
diff changeset
3941 Tue Jan 16 00:25:33 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3942
kono
parents:
diff changeset
3943 * typeck.c (build_object_ref): Finish what I started.
kono
parents:
diff changeset
3944
kono
parents:
diff changeset
3945 * parse.y (qualified_type_name): Don't check TYPE_BUILT_IN.
kono
parents:
diff changeset
3946
kono
parents:
diff changeset
3947 * decl2.c (constructor_name_full): Handle TEMPLATE_TYPE_PARMs.
kono
parents:
diff changeset
3948
kono
parents:
diff changeset
3949 * decl.c (grokdeclarator): Also accept TEMPLATE_TYPE_PARM as a
kono
parents:
diff changeset
3950 scope.
kono
parents:
diff changeset
3951
kono
parents:
diff changeset
3952 Mon Jan 15 16:19:32 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3953
kono
parents:
diff changeset
3954 * decl.c (xref_tag): Handle passing a type in directly.
kono
parents:
diff changeset
3955
kono
parents:
diff changeset
3956 * parse.y (qualified_type_name): Pull out the type.
kono
parents:
diff changeset
3957 (nested_type): Likewise.
kono
parents:
diff changeset
3958 Take types directly instead of as identifiers.
kono
parents:
diff changeset
3959 * call.c (build_scoped_method_call): Take types directly instead of
kono
parents:
diff changeset
3960 as identifiers.
kono
parents:
diff changeset
3961 * decl.c (xref_basetypes): Likewise.
kono
parents:
diff changeset
3962 * init.c (expand_member_init): Likewise.
kono
parents:
diff changeset
3963 (build_member_call): Likewise.
kono
parents:
diff changeset
3964 (build_offset_ref): Likewise.
kono
parents:
diff changeset
3965 * typeck2.c (build_scoped_ref): Likewise, remove bogus code.
kono
parents:
diff changeset
3966 * method.c (do_build_assign_ref): Likewise.
kono
parents:
diff changeset
3967 * decl.c (grokdeclarator): Handle a type appearing as the
kono
parents:
diff changeset
3968 declarator-id for constructors.
kono
parents:
diff changeset
3969 * method.c (do_build_copy_constructor): current_base_init_list now
kono
parents:
diff changeset
3970 uses the types directly, not their names.
kono
parents:
diff changeset
3971 * init.c (sort_base_init): Likewise.
kono
parents:
diff changeset
3972 (expand_member_init): Likewise.
kono
parents:
diff changeset
3973 * init.c (is_aggr_type): New function, like is_aggr_typedef.
kono
parents:
diff changeset
3974
kono
parents:
diff changeset
3975 Mon Jan 15 08:45:01 1996 Jeffrey A Law <law@cygnus.com>
kono
parents:
diff changeset
3976
kono
parents:
diff changeset
3977 * tree.c (layout_basetypes): Call build_lang_field_decl instead
kono
parents:
diff changeset
3978 of build_lang_decl if first arg is a FIELD_DECL.
kono
parents:
diff changeset
3979
kono
parents:
diff changeset
3980 Thu Jan 11 14:55:07 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3981
kono
parents:
diff changeset
3982 * decl.c (cp_finish_decl): Only clear TREE_USED if DECL_NAME is
kono
parents:
diff changeset
3983 non-empty.
kono
parents:
diff changeset
3984 * except.c (expand_start_catch_block): Set TREE_USED to avoid
kono
parents:
diff changeset
3985 warnings about the catch handler.
kono
parents:
diff changeset
3986
kono
parents:
diff changeset
3987 Mon Jan 8 17:35:12 1996 Jason Merrill <jason@yorick.cygnus.com>
kono
parents:
diff changeset
3988
kono
parents:
diff changeset
3989 * typeck.c (build_modify_expr): Use a COMPOUND_EXPR instead of
kono
parents:
diff changeset
3990 expand_target_expr.
kono
parents:
diff changeset
3991
kono
parents:
diff changeset
3992 Thu Jan 4 12:30:32 1996 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
3993
kono
parents:
diff changeset
3994 Fix access control to use trees rather than integers.
kono
parents:
diff changeset
3995 * class.c (access_{default, public, protected, private,
kono
parents:
diff changeset
3996 default_virtual, public_virtual, private_virtual}_node): Add
kono
parents:
diff changeset
3997 definitions.
kono
parents:
diff changeset
3998 (init_class_processing): Do creation of those nodes.
kono
parents:
diff changeset
3999 * cp-tree.h (access_type): Delete enum decl.
kono
parents:
diff changeset
4000 (access_{default, public, protected, private, default_virtual,
kono
parents:
diff changeset
4001 public_virtual, private_virtual}_node): Add decls.
kono
parents:
diff changeset
4002 (compute_access): Change return type.
kono
parents:
diff changeset
4003 * search.c (compute_access): Have tree return type, instead of enum.
kono
parents:
diff changeset
4004 (lookup_field): Declare THIS_V and NEW_V to be tree nodes.
kono
parents:
diff changeset
4005 * lex.c (real_yylex): Use yylval.ttype for giving the value of the
kono
parents:
diff changeset
4006 access_* node for each of RID_{PUBLIC, PRIVATE, PROTECTED}.
kono
parents:
diff changeset
4007 * parse.y (VISSPEC): Make ttype rather than itype.
kono
parents:
diff changeset
4008 (base_class_access_list): Likewise.
kono
parents:
diff changeset
4009 * *.[cy]: Change all refs of `access_public' to `access_public_node',
kono
parents:
diff changeset
4010 etc.
kono
parents:
diff changeset
4011 * call.c (build_method_call): Make ACCESS be a tree.
kono
parents:
diff changeset
4012 * class.c (alter_access, finish_struct_1, filter_struct): Likewise.
kono
parents:
diff changeset
4013 * cvt.c (convert_to_aggr): Likewise.
kono
parents:
diff changeset
4014 * init.c (build_offset_ref, resolve_offset_ref, build_delete):
kono
parents:
diff changeset
4015 Likewise.
kono
parents:
diff changeset
4016 * method.c (hack_identifier): Likewise.
kono
parents:
diff changeset
4017 * typeck.c (build_component_ref_1, build_component_ref): ): Likewise.
kono
parents:
diff changeset
4018
kono
parents:
diff changeset
4019 Thu Jan 4 11:02:20 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
4020
kono
parents:
diff changeset
4021 * typeck.c (pointer_int_sum, pointer_diff): Make code agree with C
kono
parents:
diff changeset
4022 frontend, and make it more consistent with respect to
kono
parents:
diff changeset
4023 warn_pointer_arith.
kono
parents:
diff changeset
4024
kono
parents:
diff changeset
4025 Tue Jan 2 00:13:38 1996 Rusty Russell <rusty@adelaide.maptek.com.au>
kono
parents:
diff changeset
4026
kono
parents:
diff changeset
4027 * decl.c (pushdecl): Check for duplicate parameter names.
kono
parents:
diff changeset
4028
kono
parents:
diff changeset
4029 Wed Jan 3 09:25:48 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
4030
kono
parents:
diff changeset
4031 * decl.c (expand_static_init): Call assemble_external for atexit.
kono
parents:
diff changeset
4032
kono
parents:
diff changeset
4033 Wed Jan 3 07:55:19 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
4034
kono
parents:
diff changeset
4035 * except.c (do_unwind): Remove some generated dead code.
kono
parents:
diff changeset
4036 (eh_outer_context): New routine, factor out some common code from
kono
parents:
diff changeset
4037 expand_builtin_throw and end_eh_unwinder. Add code to do return
kono
parents:
diff changeset
4038 address masking for the PA.
kono
parents:
diff changeset
4039 (expand_builtin_throw): Use eh_outer_context instead of open coding
kono
parents:
diff changeset
4040 it here.
kono
parents:
diff changeset
4041 (end_eh_unwinder): Likewise.
kono
parents:
diff changeset
4042
kono
parents:
diff changeset
4043 Tue Jan 2 17:00:56 1996 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
4044
kono
parents:
diff changeset
4045 * except.c (expand_throw): Call assemble_external for __empty, if we
kono
parents:
diff changeset
4046 use it.
kono
parents:
diff changeset
4047
kono
parents:
diff changeset
4048
kono
parents:
diff changeset
4049 Copyright (C) 1996 Free Software Foundation, Inc.
kono
parents:
diff changeset
4050
kono
parents:
diff changeset
4051 Copying and distribution of this file, with or without modification,
kono
parents:
diff changeset
4052 are permitted in any medium without royalty provided the copyright
kono
parents:
diff changeset
4053 notice and this notice are preserved.