|
|
@@ -113,7 +113,7 @@ interface
|
|
|
{ reads any routine in the implementation, or a non-method routine
|
|
|
declaration in the interface (depending on whether or not parse_only is
|
|
|
true) }
|
|
|
- procedure read_proc(flags:tread_proc_flags; usefwpd: tprocdef);
|
|
|
+ function read_proc(flags:tread_proc_flags; usefwpd: tprocdef):tprocdef;
|
|
|
|
|
|
{ parses only the body of a non nested routine; needs a correctly setup pd }
|
|
|
procedure read_proc_body(pd:tprocdef);
|
|
|
@@ -2698,7 +2698,7 @@ implementation
|
|
|
end;
|
|
|
|
|
|
|
|
|
- procedure read_proc(flags:tread_proc_flags; usefwpd: tprocdef);
|
|
|
+ function read_proc(flags:tread_proc_flags; usefwpd: tprocdef):tprocdef;
|
|
|
{
|
|
|
Parses the procedure directives, then parses the procedure body, then
|
|
|
generates the code for it
|
|
|
@@ -2719,7 +2719,7 @@ implementation
|
|
|
old_current_genericdef,
|
|
|
old_current_specializedef: tstoreddef;
|
|
|
pdflags : tpdflags;
|
|
|
- pd,firstpd : tprocdef;
|
|
|
+ firstpd : tprocdef;
|
|
|
{$ifdef genericdef_for_nested}
|
|
|
def : tprocdef;
|
|
|
srsym : tsym;
|
|
|
@@ -2741,18 +2741,18 @@ implementation
|
|
|
|
|
|
if not assigned(usefwpd) then
|
|
|
{ parse procedure declaration }
|
|
|
- pd:=parse_proc_dec(convert_flags_to_ppf,old_current_structdef)
|
|
|
+ result:=parse_proc_dec(convert_flags_to_ppf,old_current_structdef)
|
|
|
else
|
|
|
- pd:=usefwpd;
|
|
|
+ result:=usefwpd;
|
|
|
|
|
|
{ set the default function options }
|
|
|
if parse_only then
|
|
|
begin
|
|
|
- pd.forwarddef:=true;
|
|
|
+ result.forwarddef:=true;
|
|
|
{ set also the interface flag, for better error message when the
|
|
|
implementation doesn't match this header }
|
|
|
- pd.interfacedef:=true;
|
|
|
- include(pd.procoptions,po_global);
|
|
|
+ result.interfacedef:=true;
|
|
|
+ include(result.procoptions,po_global);
|
|
|
pdflags:=[pd_interface];
|
|
|
end
|
|
|
else
|
|
|
@@ -2762,83 +2762,83 @@ implementation
|
|
|
include(pdflags,pd_implemen);
|
|
|
if (not current_module.is_unit) or
|
|
|
create_smartlink_library then
|
|
|
- include(pd.procoptions,po_global);
|
|
|
- pd.forwarddef:=false;
|
|
|
+ include(result.procoptions,po_global);
|
|
|
+ result.forwarddef:=false;
|
|
|
end;
|
|
|
|
|
|
if not assigned(usefwpd) then
|
|
|
begin
|
|
|
{ parse the directives that may follow }
|
|
|
- parse_proc_directives(pd,pdflags);
|
|
|
+ parse_proc_directives(result,pdflags);
|
|
|
|
|
|
{ hint directives, these can be separated by semicolons here,
|
|
|
that needs to be handled here with a loop (PFV) }
|
|
|
- while try_consume_hintdirective(pd.symoptions,pd.deprecatedmsg) do
|
|
|
+ while try_consume_hintdirective(result.symoptions,result.deprecatedmsg) do
|
|
|
Consume(_SEMICOLON);
|
|
|
|
|
|
{ Set calling convention }
|
|
|
if parse_only then
|
|
|
- handle_calling_convention(pd,hcc_default_actions_intf)
|
|
|
+ handle_calling_convention(result,hcc_default_actions_intf)
|
|
|
else
|
|
|
- handle_calling_convention(pd,hcc_default_actions_impl)
|
|
|
+ handle_calling_convention(result,hcc_default_actions_impl)
|
|
|
end;
|
|
|
|
|
|
{ search for forward declarations }
|
|
|
- if not proc_add_definition(pd) then
|
|
|
+ if not proc_add_definition(result) then
|
|
|
begin
|
|
|
{ One may not implement a method of a type declared in a different unit }
|
|
|
- if assigned(pd.struct) and
|
|
|
- (pd.struct.symtable.moduleid<>current_module.moduleid) and
|
|
|
- not pd.is_specialization then
|
|
|
+ if assigned(result.struct) and
|
|
|
+ (result.struct.symtable.moduleid<>current_module.moduleid) and
|
|
|
+ not result.is_specialization then
|
|
|
begin
|
|
|
- MessagePos1(pd.fileinfo,parser_e_method_for_type_in_other_unit,pd.struct.typesymbolprettyname);
|
|
|
+ MessagePos1(result.fileinfo,parser_e_method_for_type_in_other_unit,result.struct.typesymbolprettyname);
|
|
|
end
|
|
|
{ A method must be forward defined (in the object declaration) }
|
|
|
- else if assigned(pd.struct) and
|
|
|
+ else if assigned(result.struct) and
|
|
|
(not assigned(old_current_structdef)) then
|
|
|
begin
|
|
|
- MessagePos1(pd.fileinfo,parser_e_header_dont_match_any_member,pd.fullprocname(false));
|
|
|
- tprocsym(pd.procsym).write_parameter_lists(pd);
|
|
|
+ MessagePos1(result.fileinfo,parser_e_header_dont_match_any_member,result.fullprocname(false));
|
|
|
+ tprocsym(result.procsym).write_parameter_lists(result);
|
|
|
end
|
|
|
else
|
|
|
begin
|
|
|
{ Give a better error if there is a forward def in the interface and only
|
|
|
a single implementation }
|
|
|
- firstpd:=tprocdef(tprocsym(pd.procsym).ProcdefList[0]);
|
|
|
- if (not pd.forwarddef) and
|
|
|
- (not pd.interfacedef) and
|
|
|
- (tprocsym(pd.procsym).ProcdefList.Count>1) and
|
|
|
+ firstpd:=tprocdef(tprocsym(result.procsym).ProcdefList[0]);
|
|
|
+ if (not result.forwarddef) and
|
|
|
+ (not result.interfacedef) and
|
|
|
+ (tprocsym(result.procsym).ProcdefList.Count>1) and
|
|
|
firstpd.forwarddef and
|
|
|
firstpd.interfacedef and
|
|
|
- not(tprocsym(pd.procsym).ProcdefList.Count>2) and
|
|
|
+ not(tprocsym(result.procsym).ProcdefList.Count>2) and
|
|
|
{ don't give an error if it may be an overload }
|
|
|
not(m_fpc in current_settings.modeswitches) and
|
|
|
- (not(po_overload in pd.procoptions) or
|
|
|
+ (not(po_overload in result.procoptions) or
|
|
|
not(po_overload in firstpd.procoptions)) then
|
|
|
begin
|
|
|
- MessagePos1(pd.fileinfo,parser_e_header_dont_match_forward,pd.fullprocname(false));
|
|
|
- tprocsym(pd.procsym).write_parameter_lists(pd);
|
|
|
+ MessagePos1(result.fileinfo,parser_e_header_dont_match_forward,result.fullprocname(false));
|
|
|
+ tprocsym(result.procsym).write_parameter_lists(result);
|
|
|
end
|
|
|
else
|
|
|
begin
|
|
|
- if pd.is_generic and not assigned(pd.struct) then
|
|
|
- tprocsym(pd.procsym).owner.includeoption(sto_has_generic);
|
|
|
+ if result.is_generic and not assigned(result.struct) then
|
|
|
+ tprocsym(result.procsym).owner.includeoption(sto_has_generic);
|
|
|
end;
|
|
|
end;
|
|
|
end;
|
|
|
|
|
|
{ Set mangled name }
|
|
|
- proc_set_mangledname(pd);
|
|
|
+ proc_set_mangledname(result);
|
|
|
|
|
|
{ inherit generic flags from parent routine }
|
|
|
if assigned(old_current_procinfo) and
|
|
|
(old_current_procinfo.procdef.defoptions*[df_specialization,df_generic]<>[]) then
|
|
|
begin
|
|
|
if df_generic in old_current_procinfo.procdef.defoptions then
|
|
|
- include(pd.defoptions,df_generic);
|
|
|
+ include(result.defoptions,df_generic);
|
|
|
if df_specialization in old_current_procinfo.procdef.defoptions then
|
|
|
begin
|
|
|
- include(pd.defoptions,df_specialization);
|
|
|
+ include(result.defoptions,df_specialization);
|
|
|
{ the procdefs encountered here are nested procdefs of which
|
|
|
their complete definition also resides inside the current token
|
|
|
stream, thus access to their genericdef is not required }
|
|
|
@@ -2846,7 +2846,7 @@ implementation
|
|
|
{ find the corresponding routine in the generic routine }
|
|
|
if not assigned(old_current_procinfo.procdef.genericdef) then
|
|
|
internalerror(2016121701);
|
|
|
- srsym:=tsym(tprocdef(old_current_procinfo.procdef.genericdef).getsymtable(gs_local).find(pd.procsym.name));
|
|
|
+ srsym:=tsym(tprocdef(old_current_procinfo.procdef.genericdef).getsymtable(gs_local).find(result.procsym.name));
|
|
|
if not assigned(srsym) or (srsym.typ<>procsym) then
|
|
|
internalerror(2016121702);
|
|
|
{ in practice the generic procdef should be at the same index
|
|
|
@@ -2857,14 +2857,14 @@ implementation
|
|
|
for i:=0 to tprocsym(srsym).procdeflist.count-1 do
|
|
|
begin
|
|
|
def:=tprocdef(tprocsym(srsym).procdeflist[i]);
|
|
|
- if (compare_paras(def.paras,pd.paras,cp_none,[cpo_ignorehidden,cpo_openequalisexact,cpo_ignoreuniv])=te_exact) and
|
|
|
- (compare_defs(def.returndef,pd.returndef,nothingn)=te_exact) then
|
|
|
+ if (compare_paras(def.paras,result.paras,cp_none,[cpo_ignorehidden,cpo_openequalisexact,cpo_ignoreuniv])=te_exact) and
|
|
|
+ (compare_defs(def.returndef,result.returndef,nothingn)=te_exact) then
|
|
|
begin
|
|
|
- pd.genericdef:=def;
|
|
|
+ result.genericdef:=def;
|
|
|
break;
|
|
|
end;
|
|
|
end;
|
|
|
- if not assigned(pd.genericdef) then
|
|
|
+ if not assigned(result.genericdef) then
|
|
|
internalerror(2016121703);
|
|
|
{$endif}
|
|
|
end;
|
|
|
@@ -2873,14 +2873,14 @@ implementation
|
|
|
{ compile procedure when a body is needed }
|
|
|
if (pd_body in pdflags) then
|
|
|
begin
|
|
|
- read_proc_body(old_current_procinfo,pd);
|
|
|
+ read_proc_body(old_current_procinfo,result);
|
|
|
end
|
|
|
else
|
|
|
begin
|
|
|
{ Handle imports }
|
|
|
- if (po_external in pd.procoptions) then
|
|
|
+ if (po_external in result.procoptions) then
|
|
|
begin
|
|
|
- import_external_proc(pd);
|
|
|
+ import_external_proc(result);
|
|
|
{$ifdef cpuhighleveltarget}
|
|
|
{ it's hard to factor this out in a virtual method, because the
|
|
|
generic version (the one inside this ifdef) doesn't fit in
|
|
|
@@ -2889,17 +2889,17 @@ implementation
|
|
|
Maybe we need another class for this kind of code that could
|
|
|
either be symcreat- or hlcgobj-based
|
|
|
}
|
|
|
- if (not pd.forwarddef) and
|
|
|
- (pd.hasforward) and
|
|
|
- (proc_get_importname(pd)<>'') then
|
|
|
+ if (not result.forwarddef) and
|
|
|
+ (result.hasforward) and
|
|
|
+ (proc_get_importname(result)<>'') then
|
|
|
begin
|
|
|
{ we cannot handle the callee-side of variadic functions (and
|
|
|
even if we could, e.g. LLVM cannot call through to something
|
|
|
else in that case) }
|
|
|
- if is_c_variadic(pd) then
|
|
|
- Message1(parser_e_callthrough_varargs,pd.fullprocname(false));
|
|
|
- call_through_new_name(pd,proc_get_importname(pd));
|
|
|
- include(pd.implprocoptions,pio_thunk);
|
|
|
+ if is_c_variadic(result) then
|
|
|
+ Message1(parser_e_callthrough_varargs,result.fullprocname(false));
|
|
|
+ call_through_new_name(result,proc_get_importname(result));
|
|
|
+ include(result.implprocoptions,pio_thunk);
|
|
|
end
|
|
|
else
|
|
|
{$endif cpuhighleveltarget}
|
|
|
@@ -2907,8 +2907,8 @@ implementation
|
|
|
create_hlcodegen;
|
|
|
hlcg.handle_external_proc(
|
|
|
current_asmdata.asmlists[al_procedures],
|
|
|
- pd,
|
|
|
- proc_get_importname(pd));
|
|
|
+ result,
|
|
|
+ proc_get_importname(result));
|
|
|
destroy_hlcodegen;
|
|
|
end
|
|
|
end;
|
|
|
@@ -2917,20 +2917,20 @@ implementation
|
|
|
{ always register public functions that are only declared in the
|
|
|
implementation section as they might be called using an external
|
|
|
declaration from another unit }
|
|
|
- if (po_global in pd.procoptions) and
|
|
|
- not pd.interfacedef and
|
|
|
- ([df_generic,df_specialization]*pd.defoptions=[]) then
|
|
|
+ if (po_global in result.procoptions) and
|
|
|
+ not result.interfacedef and
|
|
|
+ ([df_generic,df_specialization]*result.defoptions=[]) then
|
|
|
begin
|
|
|
- pd.register_def;
|
|
|
- pd.procsym.register_sym;
|
|
|
+ result.register_def;
|
|
|
+ result.procsym.register_sym;
|
|
|
end;
|
|
|
|
|
|
{ make sure that references to forward-declared functions are not }
|
|
|
{ treated as references to external symbols, needed for darwin. }
|
|
|
|
|
|
{ make sure we don't change the binding of real external symbols }
|
|
|
- if (([po_external,po_weakexternal]*pd.procoptions)=[]) and (pocall_internproc<>pd.proccalloption) then
|
|
|
- current_asmdata.DefineProcAsmSymbol(pd,pd.mangledname,pd.needsglobalasmsym);
|
|
|
+ if (([po_external,po_weakexternal]*result.procoptions)=[]) and (pocall_internproc<>result.proccalloption) then
|
|
|
+ current_asmdata.DefineProcAsmSymbol(result,result.mangledname,result.needsglobalasmsym);
|
|
|
|
|
|
current_structdef:=old_current_structdef;
|
|
|
current_genericdef:=old_current_genericdef;
|
Sven/Sarah Barth