annotate gcc/cp/ChangeLog-1993 @ 158:494b0b89df80 default tip

...
author Shinji KONO <kono@ie.u-ryukyu.ac.jp>
date Mon, 25 May 2020 18:13:55 +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 28 21:10:03 1993 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
2
kono
parents:
diff changeset
3 * cp-init.c (expand_vec_init): Remove comptypes test, as it is too
kono
parents:
diff changeset
4 harsh here.
kono
parents:
diff changeset
5
kono
parents:
diff changeset
6 Tue Dec 28 13:42:22 1993 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
7
kono
parents:
diff changeset
8 * cp-pt.c (do_pending_expansions): Decide to expand a template
kono
parents:
diff changeset
9 member function, based upon it's class type, not the class type of
kono
parents:
diff changeset
10 the first place it was declared.
kono
parents:
diff changeset
11
kono
parents:
diff changeset
12 Tue Dec 28 05:42:31 1993 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
13
kono
parents:
diff changeset
14 * cp-class.c (is_normal): New routine, use to determine when the
kono
parents:
diff changeset
15 given binfo is the normal one. (The one that should have the simple
kono
parents:
diff changeset
16 vtable name.)
kono
parents:
diff changeset
17 * cp-class.c (modify_other_vtable_entries): Use DECL_ASSEMBLER_NAME
kono
parents:
diff changeset
18 to check if two fndecls are `the same'. Sometimes this routine can
kono
parents:
diff changeset
19 modify the main vtable, and normal should be 1, in that case, so use
kono
parents:
diff changeset
20 is_normal() to determine if this is the main vtable for the class.
kono
parents:
diff changeset
21 Don't recurse down virtual bases, as they are shared, and we take
kono
parents:
diff changeset
22 care of them elsewhere.
kono
parents:
diff changeset
23 * cp-class.c (modify_vtable_entries): If we have already updated the
kono
parents:
diff changeset
24 vtable with the new virtual, don't do it again.
kono
parents:
diff changeset
25 * cp-class.c (finish_struct): Set CLASSTYPE_VFIELD_PARENT as
kono
parents:
diff changeset
26 appropriate. Do virtual function overriding in virtual bases, after
kono
parents:
diff changeset
27 normal overriding, so that the base function list in DECL_VINDEX is
kono
parents:
diff changeset
28 not overridden, before we have a chance to run through the list.
kono
parents:
diff changeset
29 Use DECL_ASSEMBLER_NAME to check if two fndecls are `the same'.
kono
parents:
diff changeset
30 Make sure we pass the right address into modify_vtable_entries.
kono
parents:
diff changeset
31 * cp-tree.h (CLASSTYPE_VFIELD_PARENT): New field to indicate which
kono
parents:
diff changeset
32 binfo is the one that has the vtable that we based our vtable on.
kono
parents:
diff changeset
33
kono
parents:
diff changeset
34 Fri Dec 24 09:40:52 1993 Michael Tiemann <tiemann@blues.cygnus.com>
kono
parents:
diff changeset
35
kono
parents:
diff changeset
36 * cp-typeck.c (c_expand_start_case): Use default_conversion to
kono
parents:
diff changeset
37 convert expression from reference type if necessary.
kono
parents:
diff changeset
38
kono
parents:
diff changeset
39 Wed Dec 22 17:58:43 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
40
kono
parents:
diff changeset
41 * cp-typeck.c (build_unary_op): Make sure that it's a TREE_LIST before
kono
parents:
diff changeset
42 trying to read its TREE_VALUE.
kono
parents:
diff changeset
43
kono
parents:
diff changeset
44 * cp-class.c (finish_struct_methods): Clear DECL_IN_AGGR_P here.
kono
parents:
diff changeset
45 (finish_struct): Instead of here.
kono
parents:
diff changeset
46
kono
parents:
diff changeset
47 Tue Dec 21 14:34:25 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
48
kono
parents:
diff changeset
49 * cp-tree.c (list_hash_lookup_or_cons): Make sure the type doesn't
kono
parents:
diff changeset
50 have TYPE_PTRMEMFUNC_P set before we try to build its
kono
parents:
diff changeset
51 CLASSTYPE_ID_AS_LIST.
kono
parents:
diff changeset
52 (get_decl_list): Likewise, when trying to read it.
kono
parents:
diff changeset
53
kono
parents:
diff changeset
54 * cp-tree.h (VTABLE_NAME): No def with NO_{DOLLAR,DOT} defined.
kono
parents:
diff changeset
55 (VTABLE_NAME_P): Use it instead of VTABLE_NAME_FORMAT.
kono
parents:
diff changeset
56
kono
parents:
diff changeset
57 Mon Dec 20 13:35:03 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
58
kono
parents:
diff changeset
59 * cp-typeck.c (rationalize_conditional_expr): New function.
kono
parents:
diff changeset
60 (unary_complex_lvalue): Use it.
kono
parents:
diff changeset
61 (build_modify_expr): Use it, since trying to do an ADDR_EXPR of it
kono
parents:
diff changeset
62 with build_unary_op won't cut it. Don't wrap the COND_EXPR with a
kono
parents:
diff changeset
63 SAVE_EXPR either.
kono
parents:
diff changeset
64
kono
parents:
diff changeset
65 * cp-decl2.c (explicit_warn_return_type): Deleted variable.
kono
parents:
diff changeset
66 (lang_decode_option): Set warn_return_type, not explicit_*, for
kono
parents:
diff changeset
67 -Wreturn-type and -Wall. This is what rest_of_compilation uses to
kono
parents:
diff changeset
68 decide if it should go into jump_optimize or not.
kono
parents:
diff changeset
69 * cp-tree.h (explicit_warn_return_type): Deleted.
kono
parents:
diff changeset
70 * cp-decl.c (grokdeclarator): Use warn_return_type, not explicit_*.
kono
parents:
diff changeset
71 (finish_function): Also complain about no return in a non-void fn if
kono
parents:
diff changeset
72 we're being pedantic (don't rely on use of -Wreturn-type).
kono
parents:
diff changeset
73
kono
parents:
diff changeset
74 Fri Dec 17 15:45:46 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
75
kono
parents:
diff changeset
76 * cp-decl.c (grokdeclarator): Forbid declaration of a function as
kono
parents:
diff changeset
77 static if it's being done inside another function.
kono
parents:
diff changeset
78
kono
parents:
diff changeset
79 * cp-search.c (compute_visibility): Check for friendship both ways.
kono
parents:
diff changeset
80
kono
parents:
diff changeset
81 Fri Dec 17 14:28:25 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
82
kono
parents:
diff changeset
83 * cp-cvt.c (build_default_binary_type_conversion): Make error
kono
parents:
diff changeset
84 messages more helpful.
kono
parents:
diff changeset
85
kono
parents:
diff changeset
86 * cp-error.c (op_as_string): New function, returns "operator =="
kono
parents:
diff changeset
87 given EQ_EXPR or suchlike.
kono
parents:
diff changeset
88
kono
parents:
diff changeset
89 Fri Dec 17 13:28:11 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
90
kono
parents:
diff changeset
91 * cp-call.c (print_n_candidates): New function.
kono
parents:
diff changeset
92 (build_overload_call_real): Use it when we complain about a call
kono
parents:
diff changeset
93 being ambiguous.
kono
parents:
diff changeset
94
kono
parents:
diff changeset
95 Fri Dec 17 12:41:17 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
96
kono
parents:
diff changeset
97 * cp-call.c (build_method_call): Fix checking for static call
kono
parents:
diff changeset
98 context.
kono
parents:
diff changeset
99
kono
parents:
diff changeset
100 * cp-method.c (build_opfncall): Call build_indirect_ref on argument
kono
parents:
diff changeset
101 to operator new.
kono
parents:
diff changeset
102
kono
parents:
diff changeset
103 * cp-init.c (build_new): Don't mess with rval when building
kono
parents:
diff changeset
104 indirect ref.
kono
parents:
diff changeset
105
kono
parents:
diff changeset
106 Thu Dec 16 16:48:05 1993 Kung Hsu <kung@cirdan.cygnus.com>
kono
parents:
diff changeset
107
kono
parents:
diff changeset
108 * cp-lex.c (default_assign_ref_body): Add check when TYPE_NESTED_
kono
parents:
diff changeset
109 NAME(type) may not be exist. It's not a problem for old compiler.
kono
parents:
diff changeset
110
kono
parents:
diff changeset
111 Thu Dec 16 14:46:06 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
112
kono
parents:
diff changeset
113 * cp-tree.h (CLASSTYPE_ALTERS_VISIBILITIES_P): Delete macro, it's
kono
parents:
diff changeset
114 never used for anything.
kono
parents:
diff changeset
115 (struct lang_type, member type_flags): Delete field
kono
parents:
diff changeset
116 `alters_visibility', and up `dummy' by 1.
kono
parents:
diff changeset
117 * cp-class.c (finish_base_struct): Delete code that copies the
kono
parents:
diff changeset
118 setting of CLASSTYPE_ALTERS_VISIBILITIES_P.
kono
parents:
diff changeset
119 (finish_struct): Delete code that sets it.
kono
parents:
diff changeset
120
kono
parents:
diff changeset
121 Thu Dec 16 14:44:39 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
122
kono
parents:
diff changeset
123 * cp-decl.c, cp-init.c, cp-typeck.c: Fix arguments to
kono
parents:
diff changeset
124 build_method_call that I messed up before.
kono
parents:
diff changeset
125
kono
parents:
diff changeset
126 * cp-search.c (get_base_distance): If protect > 1, allow immediate
kono
parents:
diff changeset
127 private base.
kono
parents:
diff changeset
128
kono
parents:
diff changeset
129 * cp-class.c (finish_base_struct): Set cant_synth_* correctly.
kono
parents:
diff changeset
130 (finish_struct): Likewise. Well, nigh-correctly; it won't deal
kono
parents:
diff changeset
131 properly with the case where a class contains an object of an
kono
parents:
diff changeset
132 ambiguous base class which has a protected op=. Should be fixed
kono
parents:
diff changeset
133 when the access control code gets overhauled.
kono
parents:
diff changeset
134 (finish_struct_methods): Set TYPE_HAS_NONPUBLIC_* correctly.
kono
parents:
diff changeset
135
kono
parents:
diff changeset
136 Thu Dec 16 12:17:06 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
137
kono
parents:
diff changeset
138 * cp-lex.c (real_yylex): Turn the code back on that deals with
kono
parents:
diff changeset
139 __FUNCTION__ and __PRETTY_FUNCTION__. Don't use lookup_name, to
kono
parents:
diff changeset
140 avoid the ambiguity problems that led to it being turned off in the
kono
parents:
diff changeset
141 first place.
kono
parents:
diff changeset
142
kono
parents:
diff changeset
143 * cp-method.c (hack_identifier): Also check for a TYPE_PTRMEMFUNC_P
kono
parents:
diff changeset
144 to see if something is a method.
kono
parents:
diff changeset
145
kono
parents:
diff changeset
146 Wed Dec 15 18:35:58 1993 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
147
kono
parents:
diff changeset
148 * cp-typeck.c (build_modify_expr): Avoid error messages on small
kono
parents:
diff changeset
149 enum bit fields.
kono
parents:
diff changeset
150 * cp-typeck.c (convert_for_assignment): Add missing argument to
kono
parents:
diff changeset
151 cp_warning and cp_pedwarn calls.
kono
parents:
diff changeset
152
kono
parents:
diff changeset
153 Wed Dec 15 18:25:32 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
154
kono
parents:
diff changeset
155 * cp-parse.y (member_init): ANSI C++ doesn't forbid old-style base
kono
parents:
diff changeset
156 initializers; it's just anachronistic.
kono
parents:
diff changeset
157
kono
parents:
diff changeset
158 * cp-decl.c (finish_decl): Don't require external-linkage arrays
kono
parents:
diff changeset
159 to have a complete type at declaration time when pedantic.
kono
parents:
diff changeset
160
kono
parents:
diff changeset
161 Tue Dec 14 11:37:23 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
162
kono
parents:
diff changeset
163 * cp-decl.c (pushdecl): Don't set DECL_CONTEXT if it's already set.
kono
parents:
diff changeset
164
kono
parents:
diff changeset
165 * cp-call.c (build_method_call): Don't dereference pointer given
kono
parents:
diff changeset
166 as instance.
kono
parents:
diff changeset
167
kono
parents:
diff changeset
168 * cp-decl.c (finish_function): Don't pass pointer to
kono
parents:
diff changeset
169 build_method_call.
kono
parents:
diff changeset
170 (finish_function): Likewise.
kono
parents:
diff changeset
171
kono
parents:
diff changeset
172 * cp-typeck.c (build_x_function_call): Likewise.
kono
parents:
diff changeset
173
kono
parents:
diff changeset
174 * cp-method.c (build_component_type_expr): Likewise.
kono
parents:
diff changeset
175
kono
parents:
diff changeset
176 * cp-init.c (build_member_call): Likewise.
kono
parents:
diff changeset
177 (build_new): Likewise.
kono
parents:
diff changeset
178
kono
parents:
diff changeset
179 Mon Dec 13 18:04:33 1993 Kung Hsu <kung@cirdan.cygnus.com>
kono
parents:
diff changeset
180
kono
parents:
diff changeset
181 * cp-decl.c (xref_tag): Fix regression created by changes made
kono
parents:
diff changeset
182 in Dec. 7 1993.
kono
parents:
diff changeset
183 * cp-decl.c (xref_defn_tag): Fix parallel nested class problem.
kono
parents:
diff changeset
184
kono
parents:
diff changeset
185 Fri Dec 10 12:40:25 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
186
kono
parents:
diff changeset
187 * cp-call.c (compute_conversion_costs_ansi) [DEBUG_MATCHING]: Print
kono
parents:
diff changeset
188 out the final evaluation of the function, so we can see if ELLIPSIS,
kono
parents:
diff changeset
189 USER, and EVIL were set at the end.
kono
parents:
diff changeset
190
kono
parents:
diff changeset
191 * cp-call.c (convert_harshness_ansi): When the parm isn't an lvalue,
kono
parents:
diff changeset
192 only go for setting TRIVIAL_CODE if we are dealing with types that
kono
parents:
diff changeset
193 are compatible.
kono
parents:
diff changeset
194
kono
parents:
diff changeset
195 Thu Dec 9 18:27:22 1993 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
196
kono
parents:
diff changeset
197 * cp-decl.c (flag_huge_objects): New flag to allow large objects.
kono
parents:
diff changeset
198 * toplev.c (lang_options): Likewise.
kono
parents:
diff changeset
199 * cp-decl2.c (flag_huge_objects, lang_f_options): Likewise.
kono
parents:
diff changeset
200 * cp-decl.c (delta_type_node): New type for delta entries.
kono
parents:
diff changeset
201 * cp-tree.h (delta_type_node): Likewise.
kono
parents:
diff changeset
202 * cp-decl.c (init_decl_processing): Setup delta_type_node.
kono
parents:
diff changeset
203 * cp-decl.c (init_decl_processing, build_ptrmemfunc_type): Use
kono
parents:
diff changeset
204 delta_type_node instead of short_integer_type_node.
kono
parents:
diff changeset
205 * cp-class.c (build_vtable_entry): Likewise.
kono
parents:
diff changeset
206
kono
parents:
diff changeset
207 Thu Dec 9 16:19:05 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
208
kono
parents:
diff changeset
209 * cp-tree.h (OPERATOR_TYPENAME_P): Define outside of
kono
parents:
diff changeset
210 NO_{DOLLAR,DOT} macro checks, so it always gets defined.
kono
parents:
diff changeset
211 (VTABLE_NAME_P): Define for NO_DOT && NO_DOLLAR_IN_LABEL.
kono
parents:
diff changeset
212
kono
parents:
diff changeset
213 Wed Dec 8 17:38:06 1993 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
214
kono
parents:
diff changeset
215 * cp-decl.c (finish_decl): Make sure things that can go into
kono
parents:
diff changeset
216 "common", do go into common, if -fcommon is given.
kono
parents:
diff changeset
217
kono
parents:
diff changeset
218 Wed Dec 8 13:01:54 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
219
kono
parents:
diff changeset
220 * cp-call.c (print_harshness) [DEBUG_MATCHING]: New function.
kono
parents:
diff changeset
221 (compute_conversion_costs_ansi) [DEBUG_MATCHING]: Print out
kono
parents:
diff changeset
222 argument matching diagnostics to make instantly clear what the
kono
parents:
diff changeset
223 compiler is doing.
kono
parents:
diff changeset
224
kono
parents:
diff changeset
225 * cp-call.c (convert_harshness_ansi): If the parm isn't an lvalue,
kono
parents:
diff changeset
226 then check to see if the penalty was increased due to
kono
parents:
diff changeset
227 signed/unsigned mismatch, and use a TRIVIAL_CODE if it wasn't.
kono
parents:
diff changeset
228
kono
parents:
diff changeset
229 Tue Dec 7 18:29:14 1993 Kung Hsu <kung@cirdan.cygnus.com>
kono
parents:
diff changeset
230
kono
parents:
diff changeset
231 * cp-decl.c (xref_tag, pushtag): Fix nested class search/resolution
kono
parents:
diff changeset
232 problem.
kono
parents:
diff changeset
233
kono
parents:
diff changeset
234 Tue Dec 7 16:09:34 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
235
kono
parents:
diff changeset
236 * cp-class.c (finish_struct): Before synthesizing methods, if no
kono
parents:
diff changeset
237 methods have yet been declared then set nonprivate_method. Don't
kono
parents:
diff changeset
238 set non_private method after synthesizing a method.
kono
parents:
diff changeset
239
kono
parents:
diff changeset
240 * cp-lex.c (extract_interface_info): If flag_alt_external_templates
kono
parents:
diff changeset
241 is set, tie emitted code to the location of template instantiation,
kono
parents:
diff changeset
242 rather than definition.
kono
parents:
diff changeset
243
kono
parents:
diff changeset
244 * cp-tree.h: Declare flag_alt_external_templates.
kono
parents:
diff changeset
245
kono
parents:
diff changeset
246 * cp-decl2.c (lang_decode_option): Support -falt-external-templates.
kono
parents:
diff changeset
247
kono
parents:
diff changeset
248 * toplev.c (lang_options): Likewise.
kono
parents:
diff changeset
249
kono
parents:
diff changeset
250 Mon Oct 4 12:50:02 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
251
kono
parents:
diff changeset
252 [changes propagated from 930810 snapshot]
kono
parents:
diff changeset
253 * cp-decl.c (init_decl_processing): Make long long available for use
kono
parents:
diff changeset
254 as SIZE_TYPE and PTRDIFF_TYPE.
kono
parents:
diff changeset
255 (finish_decl): Allow file-scope static incomplete array.
kono
parents:
diff changeset
256 (grokdeclarator): Don't pass on const and volatile fron function
kono
parents:
diff changeset
257 value type to function type.
kono
parents:
diff changeset
258 Warn here for volatile fn returning non-void type.
kono
parents:
diff changeset
259 * cp-parse.y (attrib): Accept attributes `volatile' with alias
kono
parents:
diff changeset
260 `noreturn', and `const'.
kono
parents:
diff changeset
261 * cp-typeck.c (default_conversion): Don't lose const and volatile.
kono
parents:
diff changeset
262 (build_binary_op_nodefault): Generate pedantic warning for comparison
kono
parents:
diff changeset
263 of complete pointer type with incomplete pointer type.
kono
parents:
diff changeset
264 (build_c_cast): Be careful that null pointer constant be INTEGER_CST.
kono
parents:
diff changeset
265
kono
parents:
diff changeset
266 Tue Dec 7 10:46:48 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
267
kono
parents:
diff changeset
268 * cp-init.c (expand_vec_init): When creating a temporary for copying
kono
parents:
diff changeset
269 arrays, use the type of the source, not the target.
kono
parents:
diff changeset
270
kono
parents:
diff changeset
271 * cp-cvt.c (convert): Pass an argument for errtype to
kono
parents:
diff changeset
272 convert_to_reference.
kono
parents:
diff changeset
273
kono
parents:
diff changeset
274 * cp-error.c (dump_expr, COMPONENT_REF & CALL_EXPR): Deal with
kono
parents:
diff changeset
275 methods, -> and `this'.
kono
parents:
diff changeset
276
kono
parents:
diff changeset
277 Mon Dec 6 17:12:33 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
278
kono
parents:
diff changeset
279 * cp-error.c (parm_as_string): New function; returns `this' or arg
kono
parents:
diff changeset
280 number. Corresponds to %P.
kono
parents:
diff changeset
281 (dump_expr): Deal with method calls.
kono
parents:
diff changeset
282
kono
parents:
diff changeset
283 * cp-cvt.c (convert_to_reference): Stop using warn_for_assignment.
kono
parents:
diff changeset
284 * cp-typeck.c (convert_for_assignment): Likewise.
kono
parents:
diff changeset
285 (warn_for_assignment): Lose.
kono
parents:
diff changeset
286
kono
parents:
diff changeset
287 Mon Dec 6 11:33:35 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
288
kono
parents:
diff changeset
289 * cp-call.c (ideal_candidate_ansi): Delete code that was never
kono
parents:
diff changeset
290 doing anything useful. Instead, sort once, and DO NOT wipe
kono
parents:
diff changeset
291 out any codes with EVIL_CODE, since that's what we use as a
kono
parents:
diff changeset
292 marker for the end of the list of candidates.
kono
parents:
diff changeset
293
kono
parents:
diff changeset
294 * cp-cvt.c (convert_to_aggr): Make sure to always set H_LEN.
kono
parents:
diff changeset
295
kono
parents:
diff changeset
296 Mon Dec 6 12:49:17 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
297
kono
parents:
diff changeset
298 * cp-init.c (get_aggr_from_typedef): New function, like
kono
parents:
diff changeset
299 is_aggr_typedef but returns the _TYPE.
kono
parents:
diff changeset
300
kono
parents:
diff changeset
301 * cp-call.c, cp-init.c, cp-method.c: Eradicate err_name.
kono
parents:
diff changeset
302
kono
parents:
diff changeset
303 Sun Dec 5 18:12:48 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
304
kono
parents:
diff changeset
305 * cp-lex.c (readescape): Pedwarn when a hex escape is out of range.
kono
parents:
diff changeset
306
kono
parents:
diff changeset
307 Thu Nov 25 23:50:19 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
308
kono
parents:
diff changeset
309 Delay language context change until beginning of next decl.
kono
parents:
diff changeset
310
kono
parents:
diff changeset
311 * cp-lex.h (c_header_level): Removed.
kono
parents:
diff changeset
312 (pending_lang_change): Declared.
kono
parents:
diff changeset
313 * cp-lex.c (c_header_level): Renamed from in_c_header, made static.
kono
parents:
diff changeset
314 (pending_lang_change): Defined.
kono
parents:
diff changeset
315 (check_newline): Rework code that recognizes line number and
kono
parents:
diff changeset
316 filename changes. Instead of pushing and popping lang context,
kono
parents:
diff changeset
317 increment and decrement pending_lang_change.
kono
parents:
diff changeset
318 (do_pending_lang_change): Push and pop lang context according
kono
parents:
diff changeset
319 to value of pending_lang_change.
kono
parents:
diff changeset
320 * cp-parse.y (extdefs): Use lang_extdef instead of extdef.
kono
parents:
diff changeset
321 (extdef): Same as extdef, but call do_pending_lang_change() first.
kono
parents:
diff changeset
322
kono
parents:
diff changeset
323 Mon Nov 15 15:39:15 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
324
kono
parents:
diff changeset
325 * cp-typeck.c (build_binary_op_nodefault): Warn for ordered
kono
parents:
diff changeset
326 compare of ptr with 0 only if pedantic in both cases.
kono
parents:
diff changeset
327
kono
parents:
diff changeset
328 Thu Nov 25 13:31:37 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
329
kono
parents:
diff changeset
330 Reinstate the below patch, which got lost in the Cygnus merge:
kono
parents:
diff changeset
331 Tue Nov 23 13:59:24 1993 Hallvard B Furuseth (hbf@durin.uio.no)
kono
parents:
diff changeset
332 * cp-parse.y (maybe_type_qual): Don't fail to set $$.
kono
parents:
diff changeset
333
kono
parents:
diff changeset
334 Wed Nov 17 19:03:30 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
335
kono
parents:
diff changeset
336 * cp-parse.y (attrib): Allow "ident(ident)" like the C front end.
kono
parents:
diff changeset
337
kono
parents:
diff changeset
338 Fri Oct 22 20:43:37 1993 Paul Eggert <eggert@twinsun.com>
kono
parents:
diff changeset
339
kono
parents:
diff changeset
340 * cp-lex.c (real_yylex): Diagnose floating point constants
kono
parents:
diff changeset
341 that are too large.
kono
parents:
diff changeset
342
kono
parents:
diff changeset
343 Wed Nov 17 19:10:37 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
344
kono
parents:
diff changeset
345 * cp-type2.c (build_functional_cast): ARM page 16: When a class
kono
parents:
diff changeset
346 and an object, function or enumerator are declared in the same
kono
parents:
diff changeset
347 scope with the same name, the class name is hidden.
kono
parents:
diff changeset
348
kono
parents:
diff changeset
349 Wed Nov 17 19:07:18 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
350
kono
parents:
diff changeset
351 * cp-call.c (convert_harshness_ansi): Distinguish float, double,
kono
parents:
diff changeset
352 and long double from each other when overloading.
kono
parents:
diff changeset
353 (compute_conversion_costs_{ansi,old}, build_method_call,
kono
parents:
diff changeset
354 build_overlay_call_real, convert_to_aggr): Always set and
kono
parents:
diff changeset
355 always use H_LEN member of candidate structure.
kono
parents:
diff changeset
356
kono
parents:
diff changeset
357 Mon Oct 11 23:10:53 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
358
kono
parents:
diff changeset
359 * cp-decl.c (duplicate_decls): Note redeclarations of library
kono
parents:
diff changeset
360 functions, and generate distinct warnings for them.
kono
parents:
diff changeset
361
kono
parents:
diff changeset
362 Mon Oct 4 12:26:49 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
363
kono
parents:
diff changeset
364 Support format warnings in G++.
kono
parents:
diff changeset
365
kono
parents:
diff changeset
366 * cp-tree.h: Protect against multiple inclusion.
kono
parents:
diff changeset
367 Declare all public functions in c-common.c (copy from c-tree.h).
kono
parents:
diff changeset
368 (STDIO_PROTO): Define.
kono
parents:
diff changeset
369 (warn_format): Declare.
kono
parents:
diff changeset
370 (record_format_info): Remove declaration.
kono
parents:
diff changeset
371 * cp-decl.c (init_decl_processing): Call init_function_format_info.
kono
parents:
diff changeset
372 * cp-decl2.c (lang_decode_option): Make "-Wall" include warn_format.
kono
parents:
diff changeset
373 * cp-typeck.c (build_function_call_real): Call check_function_format.
kono
parents:
diff changeset
374 (record_format_info): Remove -- obsolete stub.
kono
parents:
diff changeset
375
kono
parents:
diff changeset
376 Sat Jul 24 12:04:29 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
377
kono
parents:
diff changeset
378 * cp-decl.c (duplicate_decls): Don't warn for non-extern var decl
kono
parents:
diff changeset
379 following an extern one (for -Wredundant-decls).
kono
parents:
diff changeset
380 * cp-parse.y (primary): In statement expression case, if compstmt
kono
parents:
diff changeset
381 returns something other than a BLOCK, return it unchanged.
kono
parents:
diff changeset
382
kono
parents:
diff changeset
383 Thu Dec 2 20:44:58 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
384
kono
parents:
diff changeset
385 * cp-decl.c (warn_extern_redeclared_static): New function made
kono
parents:
diff changeset
386 from code extracted from pushdecl.
kono
parents:
diff changeset
387 (duplicate_decls, pushdecl): Call new function.
kono
parents:
diff changeset
388 (lookup_name_current_level): Allow for IDENTIFIER_GLOBAL_VALUE
kono
parents:
diff changeset
389 to be a TREE_LIST when function is declared in 'extern "C" {}'.
kono
parents:
diff changeset
390
kono
parents:
diff changeset
391 Fri Dec 3 16:01:10 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
392
kono
parents:
diff changeset
393 * cp-class.c (duplicate_tag_error): Use cp_error.
kono
parents:
diff changeset
394 (finish_base_struct): Check for ambiguity with direct base, and don't
kono
parents:
diff changeset
395 generate op= or copy ctor if it exists.
kono
parents:
diff changeset
396
kono
parents:
diff changeset
397 Fri Dec 3 15:32:34 1993 Kung Hsu <kung@cirdan.cygnus.com>
kono
parents:
diff changeset
398
kono
parents:
diff changeset
399 * cp-init.c (expand_member_init): When initializer name is null,
kono
parents:
diff changeset
400 don't try to build it now because emit_base_init will handle it.
kono
parents:
diff changeset
401
kono
parents:
diff changeset
402 Fri Dec 3 12:28:59 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
403
kono
parents:
diff changeset
404 * cp-lex.c (init_lex): Initialize input_filename to "<internal>" for
kono
parents:
diff changeset
405 code such as ExceptionHandler::operator=.
kono
parents:
diff changeset
406
kono
parents:
diff changeset
407 Fri Dec 3 10:32:08 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
408
kono
parents:
diff changeset
409 * cp-decl.c (grokdeclarator): Don't try to print out dname when
kono
parents:
diff changeset
410 complaining about arrays of references if decl_context==TYPENAME,
kono
parents:
diff changeset
411 since it will be null.
kono
parents:
diff changeset
412
kono
parents:
diff changeset
413 * cp-decl2.c: Default to flag_ansi_overloading.
kono
parents:
diff changeset
414
kono
parents:
diff changeset
415 Thu Dec 2 18:05:56 1993 Kung Hsu <kung@cirdan.cygnus.com>
kono
parents:
diff changeset
416
kono
parents:
diff changeset
417 * cp-call.c (build_method_call): Use binfo from instance if it's
kono
parents:
diff changeset
418 different from binfo (basetype_path) passed from above.
kono
parents:
diff changeset
419
kono
parents:
diff changeset
420 Wed Nov 17 19:14:29 1993 Chip Salzenberg <chip@fin.uucp>
kono
parents:
diff changeset
421
kono
parents:
diff changeset
422 cp-error.c (dump_expr): Use unsigned chars to output a
kono
parents:
diff changeset
423 TREE_REAL_CST in hex.
kono
parents:
diff changeset
424
kono
parents:
diff changeset
425 Thu Dec 2 11:05:48 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
426
kono
parents:
diff changeset
427 * cp-class.c (finish_struct): Fix typo in setting
kono
parents:
diff changeset
428 cant_synth_asn_ref.
kono
parents:
diff changeset
429
kono
parents:
diff changeset
430 * cp-tree.h (TYPE_NESTED_NAME): New macro, does
kono
parents:
diff changeset
431 DECL_NESTED_TYPENAME (TYPE_NAME (NODE)).
kono
parents:
diff changeset
432
kono
parents:
diff changeset
433 * cp-lex.c (default_copy_constructor_body): Change
kono
parents:
diff changeset
434 DECL_NAME (TYPE_NAME (btype)) to TYPE_NESTED_NAME (btype).
kono
parents:
diff changeset
435 (default_assign_ref_body): Likewise.
kono
parents:
diff changeset
436 (default_copy_constructor_body): Call operator= explicitly for
kono
parents:
diff changeset
437 base classes that have no constructor.
kono
parents:
diff changeset
438
kono
parents:
diff changeset
439 Thu Dec 2 10:47:15 1993 Michael Tiemann <tiemann@blues.cygnus.com>
kono
parents:
diff changeset
440
kono
parents:
diff changeset
441 * cp-call.c (build_method_call): If the instance variable is
kono
parents:
diff changeset
442 converted to error_mark_node when we're trying to convert it to the
kono
parents:
diff changeset
443 base type of a method we're looking up, return error_mark_node.
kono
parents:
diff changeset
444
kono
parents:
diff changeset
445 Thu Dec 2 10:41:16 1993 Torbjorn Granlund <tege@cygnus.com>
kono
parents:
diff changeset
446
kono
parents:
diff changeset
447 * cp-typeck.c (build_binary_op_nodefault): In *_DIV_EXPR *_MOD_EXPR
kono
parents:
diff changeset
448 cases, tests for unsigned operands by peeking inside a NOP_EXPR.
kono
parents:
diff changeset
449
kono
parents:
diff changeset
450 Wed Dec 1 13:33:34 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
451
kono
parents:
diff changeset
452 * cp-call.c (compute_conversion_costs_ansi): Use the size of struct
kono
parents:
diff changeset
453 harshness_code, not the size of short, for clearing out the
kono
parents:
diff changeset
454 ansi_harshness.
kono
parents:
diff changeset
455
kono
parents:
diff changeset
456 * cp-call.c (print_candidates): New function.
kono
parents:
diff changeset
457 (build_method_call): When we had some candidates, but didn't get a
kono
parents:
diff changeset
458 usable match, don't report that we got an error with the first
kono
parents:
diff changeset
459 candidate. Instead, say there were no matches, and list the
kono
parents:
diff changeset
460 candidates with print_candidates. In the second pass, make sure we
kono
parents:
diff changeset
461 clear out ever_seen, so we can accurately count the number of
kono
parents:
diff changeset
462 functions that qualified.
kono
parents:
diff changeset
463
kono
parents:
diff changeset
464 Wed Dec 1 09:53:59 1993 Torbjorn Granlund <tege@cygnus.com>
kono
parents:
diff changeset
465
kono
parents:
diff changeset
466 * cp-typeck.c (build_binary_op_nodefault): Shorten for *_MOD_EXPR
kono
parents:
diff changeset
467 only if op1 is known to be != -1.
kono
parents:
diff changeset
468 (build_binary_op_nodefault): Handle *_DIV_EXPR likewise.
kono
parents:
diff changeset
469
kono
parents:
diff changeset
470 Tue Nov 30 14:07:26 1993 Brendan Kehoe <brendan@lisa.cygnus.com>
kono
parents:
diff changeset
471
kono
parents:
diff changeset
472 * cp-method.c (hack_identifier): If the field itself is private, and
kono
parents:
diff changeset
473 not from a private base class, say so.
kono
parents:
diff changeset
474
kono
parents:
diff changeset
475 Mon Nov 29 03:00:56 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
476
kono
parents:
diff changeset
477 * cp-decl.c (grokdeclarator): Always warn on initialization of
kono
parents:
diff changeset
478 const member.
kono
parents:
diff changeset
479
kono
parents:
diff changeset
480 Wed Nov 24 00:49:35 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
481
kono
parents:
diff changeset
482 * cp-class.c (finish_struct): Set TYPE_GETS_CONST_* properly.
kono
parents:
diff changeset
483 (finish_base_struct): Set cant_synth_asn_ref properly.
kono
parents:
diff changeset
484
kono
parents:
diff changeset
485 * cp-lex.c (cons_up_default_function): Add section for operator=.
kono
parents:
diff changeset
486 (default_assign_ref_body): New function, mostly cribbed from
kono
parents:
diff changeset
487 default_copy_constructor_body.
kono
parents:
diff changeset
488
kono
parents:
diff changeset
489 * cp-class.c (base_info): Add members cant_synth_copy_ctor,
kono
parents:
diff changeset
490 cant_synth_asn_ref, no_const_asn_ref.
kono
parents:
diff changeset
491 (finish_base_struct): Update no_const_asn_ref, note that you should
kono
parents:
diff changeset
492 update cant_synth_*, propagate TYPE_GETS_ASSIGN_REF.
kono
parents:
diff changeset
493 (finish_struct): Add decls for cant_synth_*, no_const_asn_ref, and
kono
parents:
diff changeset
494 initialize them properly. Set no_const_asn_ref properly. Set
kono
parents:
diff changeset
495 cant_synth_* in some of the situations where they should be set.
kono
parents:
diff changeset
496 Propagate TYPE_GETS_ASSIGN_REF. Use cant_synth_copy_ctor. Add call
kono
parents:
diff changeset
497 to cons_up_default_function for operator=.
kono
parents:
diff changeset
498
kono
parents:
diff changeset
499 Tue Nov 23 20:24:58 1993 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
500
kono
parents:
diff changeset
501 * cp-cvt.c (convert_force): Add code to perform casting of pointer
kono
parents:
diff changeset
502 to member function types.
kono
parents:
diff changeset
503 * cp-typeck.c (build_ptrmemfunc): Add FORCE parameter to indicate
kono
parents:
diff changeset
504 when the conversion should be done, regardless.
kono
parents:
diff changeset
505 * cp-tree.h (build_ptrmemfunc): Likewise.
kono
parents:
diff changeset
506 * cp-type2.c (digest_init): Likewise.
kono
parents:
diff changeset
507 * cp-typeck.c (convert_for_assignment): Likewise.
kono
parents:
diff changeset
508
kono
parents:
diff changeset
509 Tue Nov 23 18:06:58 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
510
kono
parents:
diff changeset
511 * cp-error.c (dump_expr): Do the right thing for variables of
kono
parents:
diff changeset
512 reference type.
kono
parents:
diff changeset
513
kono
parents:
diff changeset
514 * cp-decl.c (grok_op_properties): Set TYPE_HAS_ASSIGN_REF
kono
parents:
diff changeset
515 and its kin properly.
kono
parents:
diff changeset
516 (xref_tag): Propagate TYPE_GETS_ASSIGN_REF.
kono
parents:
diff changeset
517
kono
parents:
diff changeset
518 Tue Nov 23 12:26:13 1993 Mike Stump <mrs@cygnus.com>
kono
parents:
diff changeset
519
kono
parents:
diff changeset
520 * cp-method.c (build_opfncall): Don't count pointer to member
kono
parents:
diff changeset
521 functions as aggregates here, as we don't want to look up methods in
kono
parents:
diff changeset
522 them. The compiler would core dump if we did, as they don't have
kono
parents:
diff changeset
523 normal names.
kono
parents:
diff changeset
524 * cp-typeck.c (build_indirect_ref): Improve wording on error
kono
parents:
diff changeset
525 message.
kono
parents:
diff changeset
526
kono
parents:
diff changeset
527 Mon Nov 22 14:22:23 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
528
kono
parents:
diff changeset
529 * cp-decl.c (grok_op_properties): Allow operator?: with pedwarn
kono
parents:
diff changeset
530 (since it's supported in other compiler bits).
kono
parents:
diff changeset
531
kono
parents:
diff changeset
532 * cp-method.c (report_type_mismatch): Use cp_error; ignore err_name
kono
parents:
diff changeset
533 argument.
kono
parents:
diff changeset
534
kono
parents:
diff changeset
535 * cp-error.c (dump_function_decl): Don't print return type for
kono
parents:
diff changeset
536 constructors and destructors.
kono
parents:
diff changeset
537
kono
parents:
diff changeset
538 * cp-cvt.c (cp_convert_to_pointer): Import code from
kono
parents:
diff changeset
539 convert_to_pointer so we can return error_mark_node in the case of an
kono
parents:
diff changeset
540 error, and to allow more meaningful error messages.
kono
parents:
diff changeset
541 (build_type_conversion): Don't go through void* when trying
kono
parents:
diff changeset
542 to convert to a pointer type.
kono
parents:
diff changeset
543
kono
parents:
diff changeset
544 * cp-decl.c (grokfndecl): Move call to grok_op_properties back
kono
parents:
diff changeset
545 after grokclassfn so that it's dealing with the right decl.
kono
parents:
diff changeset
546 (grok_op_properties): Don't assert !methodp for op new and op delete.
kono
parents:
diff changeset
547
kono
parents:
diff changeset
548 * cp-init.c (build_delete): Don't use TYPE_BUILT_IN (there are now
kono
parents:
diff changeset
549 no uses of it in the compiler).
kono
parents:
diff changeset
550
kono
parents:
diff changeset
551 * cp-call.c (build_scoped_method_call): Fix for destructors of simple
kono
parents:
diff changeset
552 types.
kono
parents:
diff changeset
553 (build_method_call): Likewise.
kono
parents:
diff changeset
554
kono
parents:
diff changeset
555 Fri Nov 19 12:59:38 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
556
kono
parents:
diff changeset
557 * cp-tree.c (count_functions): Abstraction function.
kono
parents:
diff changeset
558
kono
parents:
diff changeset
559 * cp-call.c (build_overload_call_real): Deal with new overloading
kono
parents:
diff changeset
560 properly, remove dead code.
kono
parents:
diff changeset
561
kono
parents:
diff changeset
562 * gcc.c (default_compilers): Generate and use .ii files in the
kono
parents:
diff changeset
563 intermediate stage of compiling C++ source.
kono
parents:
diff changeset
564
kono
parents:
diff changeset
565 Fri Nov 19 11:26:09 1993 Jim Wilson <wilson@sphagnum.cygnus.com>
kono
parents:
diff changeset
566
kono
parents:
diff changeset
567 * cp-expr.c (cplus_expand_expr): Make call_target a valid memory
kono
parents:
diff changeset
568 address before using it, so it can be later safely compared.
kono
parents:
diff changeset
569
kono
parents:
diff changeset
570 Fri Nov 12 15:30:27 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
571
kono
parents:
diff changeset
572 * cp-pt.c (tsubst): Deal with new overloading.
kono
parents:
diff changeset
573
kono
parents:
diff changeset
574 * cp-typeck.c (fntype_p): Is the arg function type?
kono
parents:
diff changeset
575 (comp_target_parms): pedwarn on conversion from (anything) to (...).
kono
parents:
diff changeset
576 (build_x_function_call): Deal with new overloading.
kono
parents:
diff changeset
577
kono
parents:
diff changeset
578 * cp-tree.c (decl_list_length): Deal with new overloading.
kono
parents:
diff changeset
579 (decl_value_member): Like value_member, but for DECL_CHAINs.
kono
parents:
diff changeset
580
kono
parents:
diff changeset
581 * cp-decl.c (duplicate_decls): Deal with new overloading.
kono
parents:
diff changeset
582 (start_decl): Likewise.
kono
parents:
diff changeset
583
kono
parents:
diff changeset
584 * cp-class.c (instantiate_type): Deal with new overloading.
kono
parents:
diff changeset
585
kono
parents:
diff changeset
586 * cp-call.c (convert_harshness_ansi): Deal with new overloading.
kono
parents:
diff changeset
587 (convert_harshness_old): Deal with new overloading.
kono
parents:
diff changeset
588 (build_overload_call_real): Likewise.
kono
parents:
diff changeset
589
kono
parents:
diff changeset
590 Mon Nov 8 13:50:49 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
591
kono
parents:
diff changeset
592 * cp-tree.c (get_unique_fn): New function; returns FUNCTION_DECL
kono
parents:
diff changeset
593 if unambiguous, NULL_TREE otherwise.
kono
parents:
diff changeset
594 (get_first_fn): Returns the first appropriate FUNCTION_DECL.
kono
parents:
diff changeset
595 (is_overloaded_fn): Returns whether or not the passed tree is
kono
parents:
diff changeset
596 a function or list of functions.
kono
parents:
diff changeset
597
kono
parents:
diff changeset
598 * cp-init.c (init_init_processing): Use `get_first_fn' to find
kono
parents:
diff changeset
599 the FUNCTION_DEFN for new and delete.
kono
parents:
diff changeset
600
kono
parents:
diff changeset
601 * cp-decl.c (push_overloaded_decl): Use new overloading strategy, cut
kono
parents:
diff changeset
602 code size in half (I spit on special cases).
kono
parents:
diff changeset
603
kono
parents:
diff changeset
604 Tue Sep 7 20:03:33 1993 Jason Merrill <jason@deneb.cygnus.com>
kono
parents:
diff changeset
605
kono
parents:
diff changeset
606 * cp-decl.c: Allow references and template type parameters as well
kono
parents:
diff changeset
607
kono
parents:
diff changeset
608
kono
parents:
diff changeset
609 Copyright (C) 1993 Free Software Foundation, Inc.
kono
parents:
diff changeset
610
kono
parents:
diff changeset
611 Copying and distribution of this file, with or without modification,
kono
parents:
diff changeset
612 are permitted in any medium without royalty provided the copyright
kono
parents:
diff changeset
613 notice and this notice are preserved.