diff --git a/compiler/defcmp.pas b/compiler/defcmp.pas index 5825a5a0c2..a7418e901c 100644 --- a/compiler/defcmp.pas +++ b/compiler/defcmp.pas @@ -35,7 +35,9 @@ interface type { if acp is cp_all the var const or nothing are considered equal } - compare_type = ( cp_none, cp_value_equal_const, cp_all,cp_procvar); + tcompare_paras_type = ( cp_none, cp_value_equal_const, cp_all,cp_procvar); + tcompare_paras_option = (cpo_allowdefaults,cpo_ignorehidden,cpo_allowconvert); + tcompare_paras_options = set of tcompare_paras_option; tconverttype = ( tc_equal, @@ -103,7 +105,7 @@ interface search for a routine with default parameters, before searching for the same definition with no parameters) } - function compare_paras(paralist1,paralist2 : TLinkedList; acp : compare_type;allowdefaults,ignorehidden:boolean):tequaltype; + function compare_paras(paralist1,paralist2 : TLinkedList; acp : tcompare_paras_type; cpoptions: tcompare_paras_options):tequaltype; { True if a function can be assigned to a procvar } { changed first argument type to pabstractprocdef so that it can also be } @@ -1065,7 +1067,7 @@ implementation end; - function compare_paras(paralist1,paralist2 : TLinkedList; acp : compare_type;allowdefaults,ignorehidden:boolean):tequaltype; + function compare_paras(paralist1,paralist2 : TLinkedList; acp : tcompare_paras_type; cpoptions: tcompare_paras_options):tequaltype; var currpara1, currpara2 : TParaItem; @@ -1079,7 +1081,7 @@ implementation lowesteq:=high(tequaltype); currpara1:=TParaItem(paralist1.first); currpara2:=TParaItem(paralist2.first); - if ignorehidden then + if cpo_ignorehidden in cpoptions then begin while assigned(currpara1) and currpara1.is_hidden do currpara1:=tparaitem(currpara1.next); @@ -1165,7 +1167,7 @@ implementation end; currpara1:=TParaItem(currpara1.next); currpara2:=TParaItem(currpara2.next); - if ignorehidden then + if cpo_ignorehidden in cpoptions then begin while assigned(currpara1) and currpara1.is_hidden do currpara1:=tparaitem(currpara1.next); @@ -1177,7 +1179,7 @@ implementation when one list is empty and the other has a parameter with default value assigned then the parameters are also equal } if ((currpara1=nil) and (currpara2=nil)) or - (allowdefaults and + ((cpo_allowdefaults in cpoptions) and ((assigned(currpara1) and assigned(currpara1.defaultvalue)) or (assigned(currpara2) and assigned(currpara2.defaultvalue)))) then compare_paras:=lowesteq; @@ -1211,7 +1213,7 @@ implementation { return equal type based on the parameters, but a proc->procvar is never exact, so map an exact match of the parameters to te_equal } - eq:=compare_paras(def1.para,def2.para,cp_procvar,false,false); + eq:=compare_paras(def1.para,def2.para,cp_procvar,[]); if eq=te_exact then eq:=te_equal; proc_to_procvar_equal:=eq; @@ -1221,7 +1223,10 @@ implementation end. { $Log$ - Revision 1.34 2003-10-26 14:11:35 florian + Revision 1.35 2003-10-30 16:23:13 peter + * don't search for overloads in parents for constructors + + Revision 1.34 2003/10/26 14:11:35 florian * fixed web bug 2129: explicit float casts in Delphi mode must be handled by the default code Revision 1.33 2003/10/14 12:23:06 florian diff --git a/compiler/ncal.pas b/compiler/ncal.pas index 0447b50e9a..8407d300a9 100644 --- a/compiler/ncal.pas +++ b/compiler/ncal.pas @@ -1229,13 +1229,7 @@ type for class entries as the tree keeps always the same } if (not symtableprocentry.overloadchecked) and (symtableprocentry.owner.symtabletype=objectsymtable) and - ( - ( - (symtableprocentry.first_procdef.proctypeoption=potype_constructor) and - is_class(tdef(symtableprocentry.owner.defowner)) - ) or - (po_overload in symtableprocentry.first_procdef.procoptions) - ) then + (po_overload in symtableprocentry.first_procdef.procoptions) then search_class_overloads(symtableprocentry); { when the class passed is defined in this unit we @@ -1320,7 +1314,7 @@ type while assigned(hp) do begin { Only compare visible parameters for the user } - if compare_paras(hp^.data.para,pd.para,cp_value_equal_const,false,true)>=te_equal then + if compare_paras(hp^.data.para,pd.para,cp_value_equal_const,[cpo_ignorehidden])>=te_equal then begin found:=true; break; @@ -2591,7 +2585,10 @@ begin end. { $Log$ - Revision 1.201 2003-10-29 22:01:20 florian + Revision 1.202 2003-10-30 16:23:13 peter + * don't search for overloads in parents for constructors + + Revision 1.201 2003/10/29 22:01:20 florian * fixed passing of dyn. arrays to open array parameters Revision 1.200 2003/10/23 14:44:07 peter diff --git a/compiler/nobj.pas b/compiler/nobj.pas index 18f7c9e336..30c4fcec55 100644 --- a/compiler/nobj.pas +++ b/compiler/nobj.pas @@ -634,7 +634,7 @@ implementation begin if tstoredsym(procdefcoll^.data.procsym).is_visible_for_object(pd._class) and (not(pdoverload or hasoverloads) or - (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,false,false)>=te_equal)) then + (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,[])>=te_equal)) then begin if is_visible then procdefcoll^.hidden:=true; @@ -652,7 +652,7 @@ implementation begin { we start a new virtual tree, hide the old } if (not(pdoverload or hasoverloads) or - (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,false,false)>=te_equal)) and + (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,[])>=te_equal)) and (tstoredsym(procdefcoll^.data.procsym).is_visible_for_object(pd._class)) then begin if is_visible then @@ -668,7 +668,7 @@ implementation { do nothing, the error will follow when adding the entry } end { same parameters } - else if (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,false,false)>=te_equal) then + else if (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,[])>=te_equal) then begin { overload is inherited } if (po_overload in procdefcoll^.data.procoptions) then @@ -734,7 +734,7 @@ implementation if the new defintion has not the overload directive } if is_visible and ((not(pdoverload or hasoverloads)) or - (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,false,false)>=te_equal)) then + (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,[])>=te_equal)) then procdefcoll^.hidden:=true; end; end @@ -744,7 +744,7 @@ implementation has not the overload directive } if is_visible and ((not pdoverload) or - (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,false,false)>=te_equal)) then + (compare_paras(procdefcoll^.data.para,pd.para,cp_value_equal_const,[])>=te_equal)) then procdefcoll^.hidden:=true; end; end; { not hidden } @@ -1057,7 +1057,7 @@ implementation for i:=1 to tprocsym(sym).procdef_count do begin implprocdef:=tprocsym(sym).procdef[i]; - if (compare_paras(proc.para,implprocdef.para,cp_none,false,false)>=te_equal) and + if (compare_paras(proc.para,implprocdef.para,cp_none,[])>=te_equal) and (proc.proccalloption=implprocdef.proccalloption) then begin gintfgetcprocdef:=implprocdef; @@ -1368,7 +1368,10 @@ initialization end. { $Log$ - Revision 1.54 2003-10-29 19:48:50 peter + Revision 1.55 2003-10-30 16:23:13 peter + * don't search for overloads in parents for constructors + + Revision 1.54 2003/10/29 19:48:50 peter * renamed mangeldname_prefix to make_mangledname and made it more generic * make_mangledname is now also used for internal threadvar/resstring diff --git a/compiler/pdecobj.pas b/compiler/pdecobj.pas index 57b65e509c..d45db62f6d 100644 --- a/compiler/pdecobj.pas +++ b/compiler/pdecobj.pas @@ -387,7 +387,7 @@ implementation { Insert hidden parameters } calc_parast(readprocdef); { search procdefs matching readprocdef } - p.readaccess.procdef:=Tprocsym(sym).search_procdef_bypara(readprocdef.para,p.proptype.def,true,false); + p.readaccess.procdef:=Tprocsym(sym).search_procdef_bypara(readprocdef.para,p.proptype.def,[cpo_allowdefaults]); if not assigned(p.readaccess.procdef) then Message(parser_e_ill_property_access_sym); end; @@ -431,7 +431,7 @@ implementation { Insert hidden parameters } calc_parast(writeprocdef); { search procdefs matching writeprocdef } - p.writeaccess.procdef:=Tprocsym(sym).search_procdef_bypara(writeprocdef.para,writeprocdef.rettype.def,true,false); + p.writeaccess.procdef:=Tprocsym(sym).search_procdef_bypara(writeprocdef.para,writeprocdef.rettype.def,[cpo_allowdefaults]); if not assigned(p.writeaccess.procdef) then Message(parser_e_ill_property_access_sym); end; @@ -1157,7 +1157,10 @@ implementation end. { $Log$ - Revision 1.71 2003-10-22 15:22:33 peter + Revision 1.72 2003-10-30 16:23:13 peter + * don't search for overloads in parents for constructors + + Revision 1.71 2003/10/22 15:22:33 peter * fixed unitsym-globalsymtable relation so the uses of a unit is counted correctly diff --git a/compiler/pdecsub.pas b/compiler/pdecsub.pas index 1b15fb5645..0380c0db0d 100644 --- a/compiler/pdecsub.pas +++ b/compiler/pdecsub.pas @@ -1892,7 +1892,7 @@ const ) or { check arguments } ( - (compare_paras(pd.para,hd.para,cp_none,false,false)>=te_equal) and + (compare_paras(pd.para,hd.para,cp_none,[])>=te_equal) and { for operators equal_paras is not enough !! } ((pd.proctypeoption<>potype_operator) or (optoken<>_ASSIGNMENT) or equal_defs(hd.rettype.def,pd.rettype.def)) @@ -1911,7 +1911,7 @@ const ( (m_repeat_forward in aktmodeswitches) and (not((pd.maxparacount=0) or - (compare_paras(pd.para,hd.para,cp_all,false,false)>=te_equal))) + (compare_paras(pd.para,hd.para,cp_all,[])>=te_equal))) ) or ( ((m_repeat_forward in aktmodeswitches) or @@ -2132,7 +2132,10 @@ const end. { $Log$ - Revision 1.149 2003-10-28 15:36:01 peter + Revision 1.150 2003-10-30 16:23:13 peter + * don't search for overloads in parents for constructors + + Revision 1.149 2003/10/28 15:36:01 peter * absolute to object field supported, fixes tb0458 Revision 1.148 2003/10/07 21:14:33 peter diff --git a/compiler/symsym.pas b/compiler/symsym.pas index d3023764aa..b1c1a7313c 100644 --- a/compiler/symsym.pas +++ b/compiler/symsym.pas @@ -31,7 +31,7 @@ interface { target } globtype,globals, { symtable } - symconst,symbase,symtype,symdef, + symconst,symbase,symtype,symdef,defcmp, { ppu } ppu,symppu, cclasses,symnot, @@ -132,7 +132,7 @@ interface procedure deref;override; procedure addprocdef(p:tprocdef); procedure addprocdef_deref(const d:tderef); - procedure add_para_match_to(Aprocsym:Tprocsym); + procedure add_para_match_to(Aprocsym:Tprocsym;cpoptions:tcompare_paras_options); procedure concat_procdefs_to(s:Tprocsym); procedure foreach_procdef_static(proc2call:Tprocdefcallback;arg:pointer); function first_procdef:Tprocdef; @@ -141,8 +141,7 @@ interface function search_procdef_bytype(pt:Tproctypeoption):Tprocdef; function search_procdef_bypara(params:Tlinkedlist; retdef:tdef; - allowconvert, - allowdefault:boolean):Tprocdef; + cpoptions:tcompare_paras_options):Tprocdef; function search_procdef_byprocvardef(d:Tprocvardef):Tprocdef; function search_procdef_unary_operator(firstpara:Tdef):Tprocdef; function search_procdef_assignment_operator(fromdef,todef:tdef):Tprocdef; @@ -375,7 +374,7 @@ implementation { target } systems, { symtable } - defutil,defcmp,symtable, + defutil,symtable, {$ifdef GDB} gdb, {$endif GDB} @@ -866,7 +865,7 @@ implementation procedure tprocsym.deref; var - prev,hp,p : pprocdeflist; + p : pprocdeflist; begin { We have removed the overloaded entries, because they are not valid anymore and we can't deref them because @@ -875,13 +874,11 @@ implementation unchain_overload; { Deref our own procdefs } p:=pdlistfirst; - prev:=nil; while assigned(p) do begin if not p^.own then internalerror(200310291); p^.def:=tprocdef(p^.defderef.resolve); - prev:=p; p:=p^.next; end; end; @@ -953,14 +950,14 @@ implementation end; - procedure Tprocsym.add_para_match_to(Aprocsym:Tprocsym); + procedure Tprocsym.add_para_match_to(Aprocsym:Tprocsym;cpoptions:tcompare_paras_options); var pd:pprocdeflist; begin pd:=pdlistfirst; while assigned(pd) do begin - if Aprocsym.search_procdef_bypara(pd^.def.para,nil,false,true)=nil then + if Aprocsym.search_procdef_bypara(pd^.def.para,nil,cpoptions)=nil then Aprocsym.addprocdef(pd^.def); pd:=pd^.next; end; @@ -1050,8 +1047,7 @@ implementation function Tprocsym.search_procdef_bypara(params:Tlinkedlist; retdef:tdef; - allowconvert, - allowdefault:boolean):Tprocdef; + cpoptions:tcompare_paras_options):Tprocdef; var pd : pprocdeflist; eq : tequaltype; @@ -1065,11 +1061,11 @@ implementation else eq:=te_equal; if (eq>=te_equal) or - (allowconvert and (eq>te_incompatible)) then + ((cpo_allowconvert in cpoptions) and (eq>te_incompatible)) then begin - eq:=compare_paras(pd^.def.para,params,cp_value_equal_const,allowdefault,false); + eq:=compare_paras(pd^.def.para,params,cp_value_equal_const,cpoptions); if (eq>=te_equal) or - (allowconvert and (eq>te_incompatible)) then + ((cpo_allowconvert in cpoptions) and (eq>te_incompatible)) then begin search_procdef_bypara:=pd^.def; break; @@ -2687,7 +2683,10 @@ implementation end. { $Log$ - Revision 1.133 2003-10-29 21:56:28 peter + Revision 1.134 2003-10-30 16:23:13 peter + * don't search for overloads in parents for constructors + + Revision 1.133 2003/10/29 21:56:28 peter * procsym.deref derefs only own procdefs * reset paracount in procdef.deref so a second deref doesn't increase the paracounts to invalid values diff --git a/compiler/symtable.pas b/compiler/symtable.pas index 93b5cf557f..2b176d506e 100644 --- a/compiler/symtable.pas +++ b/compiler/symtable.pas @@ -262,7 +262,7 @@ implementation { target } systems, { symtable } - symutil, + symutil,defcmp, { module } fmodule, {$ifdef GDB} @@ -2131,7 +2131,7 @@ implementation internalerror(200111022); if srsym.is_visible_for_object(tobjectdef(aprocsym.owner.defowner)) then begin - srsym.add_para_match_to(Aprocsym); + srsym.add_para_match_to(Aprocsym,[cpo_ignorehidden,cpo_allowdefaults]); { we can stop if the overloads were already added for the found symbol } if srsym.overloadchecked then @@ -2297,7 +2297,10 @@ implementation end. { $Log$ - Revision 1.120 2003-10-23 14:44:07 peter + Revision 1.121 2003-10-30 16:23:13 peter + * don't search for overloads in parents for constructors + + Revision 1.120 2003/10/23 14:44:07 peter * splitted buildderef and buildderefimpl to fix interface crc calculation