paweld/fpc
1
0
Fork 0
mirror of https://gitlab.com/freepascal.org/fpc/source.git synced 2025-08-12 11:06:19 +02:00
Code Issues Packages Projects Releases Wiki Activity

* set_varstate cleanup

Browse Source
This commit is contained in:
peter 2003-10-08 19:19:45 +00:00
parent f187323816
commit 95f132db3d
17 changed files with 182 additions and 189 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
compiler/htypechk.pas
View File

@ -29,7 +29,7 @@ interface
uses uses
tokens, tokens,
node, node,
symtype,symdef; symconst,symtype,symdef;
type type
Ttok2nodeRec=record Ttok2nodeRec=record
@ -94,14 +94,8 @@ interface
function is_procsym_load(p:tnode):boolean; function is_procsym_load(p:tnode):boolean;
procedure test_local_to_procvar(from_def:tprocvardef;to_def:tdef); procedure test_local_to_procvar(from_def:tprocvardef;to_def:tdef);
{
type
tvarstaterequire = (vsr_can_be_undefined,vsr_must_be_valid,
vsr_is_used_after,vsr_must_be_valid_and_is_used_after); }
{ sets varsym varstate field correctly } { sets varsym varstate field correctly }
procedure unset_varstate(p : tnode); procedure set_varstate(p:tnode;newstate:tvarstate;must_be_valid:boolean);
procedure set_varstate(p : tnode;must_be_valid : boolean);
{ sets the callunique flag, if the node is a vecn, } { sets the callunique flag, if the node is a vecn, }
{ takes care of type casts etc. } { takes care of type casts etc. }
@ -118,8 +112,8 @@ implementation
uses uses
globtype,systems, globtype,systems,
cutils,verbose,globals, cutils,verbose,globals,
symconst,symsym,symtable, symsym,symtable,
defutil,defcmp,cpubase, defutil,defcmp,
ncnv,nld, ncnv,nld,
nmem,ncal,nmat, nmem,ncal,nmat,
cgbase,procinfo cgbase,procinfo
@ -580,7 +574,7 @@ implementation
end; end;
procedure set_varstate(p : tnode;must_be_valid : boolean); procedure set_varstate(p:tnode;newstate:tvarstate;must_be_valid:boolean);
var var
hsym : tvarsym; hsym : tvarsym;
begin begin
@ -607,72 +601,44 @@ implementation
p:=tunarynode(p).left; p:=tunarynode(p).left;
vecn: vecn:
begin begin
set_varstate(tbinarynode(p).right,true); set_varstate(tbinarynode(p).right,vs_used,true);
if not(tunarynode(p).left.resulttype.def.deftype in [stringdef,arraydef]) then if not(tunarynode(p).left.resulttype.def.deftype in [stringdef,arraydef]) then
must_be_valid:=true; must_be_valid:=true;
p:=tunarynode(p).left; p:=tunarynode(p).left;
end; end;
{ do not parse calln } { do not parse calln }
calln : calln :
break; break;
callparan :
begin
set_varstate(tbinarynode(p).right,must_be_valid);
p:=tunarynode(p).left;
end;
loadn : loadn :
begin begin
if (tloadnode(p).symtableentry.typ=varsym) then if (tloadnode(p).symtableentry.typ=varsym) then
begin begin
hsym:=tvarsym(tloadnode(p).symtableentry); hsym:=tvarsym(tloadnode(p).symtableentry);
if must_be_valid and (nf_first_use in p.flags) then if must_be_valid and (hsym.varstate=vs_declared) then
begin
if (hsym.varstate=vs_declared_and_first_found) or
(hsym.varstate=vs_set_but_first_not_passed) then
begin
if (assigned(hsym.owner) and
assigned(current_procinfo) and
(hsym.owner=current_procinfo.procdef.localst)) then
begin
if (vo_is_funcret in hsym.varoptions) then
CGMessage(sym_w_function_result_not_set)
else
if tloadnode(p).symtable.symtabletype=localsymtable then
CGMessage1(sym_n_uninitialized_local_variable,hsym.realname)
else
CGMessage1(sym_n_uninitialized_variable,hsym.realname);
end;
end;
end;
if (nf_first_use in p.flags) then
begin
if hsym.varstate=vs_declared_and_first_found then
begin
{ this can only happen at left of an assignment, no ? PM }
if (parsing_para_level=0) and not must_be_valid then
hsym.varstate:=vs_assigned
else
hsym.varstate:=vs_used;
end
else
if hsym.varstate=vs_set_but_first_not_passed then
hsym.varstate:=vs_used;
exclude(p.flags,nf_first_use);
end
else
begin begin
if (hsym.varstate=vs_assigned) and { Give warning/note for uninitialized locals }
(must_be_valid or (parsing_para_level>0) or if assigned(hsym.owner) and
(p.resulttype.def.deftype=procvardef)) then not(vo_is_external in hsym.varoptions) and
hsym.varstate:=vs_used; (hsym.owner.symtabletype=localsymtable) and
if (hsym.varstate=vs_declared_and_first_found) and (hsym.owner=current_procinfo.procdef.localst) then
(must_be_valid or (parsing_para_level>0) or begin
(p.resulttype.def.deftype=procvardef)) then if (vo_is_funcret in hsym.varoptions) then
hsym.varstate:=vs_set_but_first_not_passed; CGMessage(sym_w_function_result_not_set)
else
if tloadnode(p).symtable.symtabletype=localsymtable then
CGMessage1(sym_n_uninitialized_local_variable,hsym.realname)
else
CGMessage1(sym_n_uninitialized_variable,hsym.realname);
end;
end; end;
{ don't override vs_used with vs_assigned }
if hsym.varstate<>vs_used then
hsym.varstate:=newstate;
end; end;
break; break;
end; end;
callparan :
internalerror(200310081);
else else
break; break;
end;{case } end;{case }
@ -680,23 +646,6 @@ implementation
end; end;
procedure unset_varstate(p : tnode);
begin
while assigned(p) do
begin
exclude(p.flags,nf_varstateset);
case p.nodetype of
typeconvn,
subscriptn,
vecn :
p:=tunarynode(p).left;
else
break;
end;
end;
end;
procedure set_unique(p : tnode); procedure set_unique(p : tnode);
begin begin
while assigned(p) do while assigned(p) do
@ -918,9 +867,6 @@ implementation
end end
else else
begin begin
{ set the assigned flag for varsyms }
if (tvarsym(tloadnode(hp).symtableentry).varstate=vs_declared) then
tvarsym(tloadnode(hp).symtableentry).varstate:=vs_assigned;
valid_for_assign:=true; valid_for_assign:=true;
exit; exit;
end; end;
@ -995,7 +941,10 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.68 2003-10-05 21:21:52 peter Revision 1.69 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.68 2003/10/05 21:21:52 peter
* c style array of const generates callparanodes * c style array of const generates callparanodes
* varargs paraloc fixes * varargs paraloc fixes

13
compiler/nadd.pas
View File

@ -78,7 +78,7 @@ implementation
{$ifdef state_tracking} {$ifdef state_tracking}
nstate, nstate,
{$endif} {$endif}
cpubase,cpuinfo,procinfo; cpuinfo,procinfo;
{***************************************************************************** {*****************************************************************************
@ -124,8 +124,8 @@ implementation
resulttypepass(left); resulttypepass(left);
resulttypepass(right); resulttypepass(right);
{ both left and right need to be valid } { both left and right need to be valid }
set_varstate(left,true); set_varstate(left,vs_used,true);
set_varstate(right,true); set_varstate(right,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -1526,7 +1526,9 @@ implementation
function taddnode.pass_1 : tnode; function taddnode.pass_1 : tnode;
var var
{$ifdef addstringopt}
hp : tnode; hp : tnode;
{$endif addstringopt}
lt,rt : tnodetype; lt,rt : tnodetype;
rd,ld : tdef; rd,ld : tdef;
begin begin
@ -1873,7 +1875,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.96 2003-10-01 20:34:48 peter Revision 1.97 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.96 2003/10/01 20:34:48 peter
* procinfo unit contains tprocinfo * procinfo unit contains tprocinfo
* cginfo renamed to cgbase * cginfo renamed to cgbase
* moved cgmessage to verbose * moved cgmessage to verbose

21
compiler/ncal.pas
View File

@ -640,13 +640,13 @@ type
floatdef : floatdef :
inserttypeconv(left,s64floattype); inserttypeconv(left,s64floattype);
end; end;
set_varstate(left,true); set_varstate(left,vs_used,true);
resulttype:=left.resulttype; resulttype:=left.resulttype;
end end
else else
if (paraitem.is_hidden) then if (paraitem.is_hidden) then
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
resulttype:=left.resulttype; resulttype:=left.resulttype;
end end
else else
@ -776,10 +776,10 @@ type
if do_count then if do_count then
begin begin
{ not completly proper, but avoids some warnings } if paraitem.paratyp in [vs_var,vs_out] then
{if (paraitem.paratyp in [vs_var,vs_out]) then set_varstate(left,vs_used,false)
set_funcret_is_valid(left); } else
set_varstate(left,not(paraitem.paratyp in [vs_var,vs_out])); set_varstate(left,vs_used,true);
end; end;
{ must only be done after typeconv PM } { must only be done after typeconv PM }
resulttype:=paraitem.paratype; resulttype:=paraitem.paratype;
@ -1995,7 +1995,7 @@ type
{ procedure variable ? } { procedure variable ? }
if assigned(right) then if assigned(right) then
begin begin
set_varstate(right,true); set_varstate(right,vs_used,true);
resulttypepass(right); resulttypepass(right);
if codegenerror then if codegenerror then
exit; exit;
@ -2271,7 +2271,7 @@ type
method_must_be_valid:=false method_must_be_valid:=false
else else
method_must_be_valid:=true; method_must_be_valid:=true;
set_varstate(methodpointer,method_must_be_valid); set_varstate(methodpointer,vs_used,method_must_be_valid);
{ The object is already used if it is called once } { The object is already used if it is called once }
if (hpt.nodetype=loadn) and if (hpt.nodetype=loadn) and
@ -2609,7 +2609,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.192 2003-10-07 21:14:32 peter Revision 1.193 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.192 2003/10/07 21:14:32 peter
* compare_paras() has a parameter to ignore hidden parameters * compare_paras() has a parameter to ignore hidden parameters
* cross unit overload searching ignores hidden parameters when * cross unit overload searching ignores hidden parameters when
comparing parameter lists. Now function(string):string is comparing parameter lists. Now function(string):string is

7
compiler/ncginl.pas
View File

@ -448,7 +448,7 @@ implementation
begin begin
location_reset(location,LOC_REGISTER,OS_ADDR); location_reset(location,LOC_REGISTER,OS_ADDR);
location.register:=rg.getaddressregister(exprasmlist); location.register:=rg.getaddressregister(exprasmlist);
reference_reset_symbol(href,tstoreddef(ttypenode(tcallparanode(left).left).resulttype.def).get_rtti_label(fullrtti),0); reference_reset_symbol(href,tstoreddef(left.resulttype.def).get_rtti_label(fullrtti),0);
cg.a_loadaddr_ref_reg(exprasmlist,href,location.register); cg.a_loadaddr_ref_reg(exprasmlist,href,location.register);
end; end;
@ -656,7 +656,10 @@ end.
{ {
$Log$ $Log$
Revision 1.44 2003-10-05 21:21:52 peter Revision 1.45 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.44 2003/10/05 21:21:52 peter
* c style array of const generates callparanodes * c style array of const generates callparanodes
* varargs paraloc fixes * varargs paraloc fixes

13
compiler/ncnv.pas
View File

@ -1858,8 +1858,8 @@ implementation
resulttypepass(left); resulttypepass(left);
resulttypepass(right); resulttypepass(right);
set_varstate(left,true); set_varstate(left,vs_used,true);
set_varstate(right,true); set_varstate(right,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -1967,8 +1967,8 @@ implementation
resulttypepass(right); resulttypepass(right);
resulttypepass(left); resulttypepass(left);
set_varstate(right,true); set_varstate(right,vs_used,true);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -2104,7 +2104,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.121 2003-10-07 14:30:27 peter Revision 1.122 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.121 2003/10/07 14:30:27 peter
* fix 2720 * fix 2720
Revision 1.120 2003/10/01 20:34:48 peter Revision 1.120 2003/10/01 20:34:48 peter

25
compiler/nflw.pas
View File

@ -380,7 +380,7 @@ implementation
{ loop instruction } { loop instruction }
if assigned(right) then if assigned(right) then
resulttypepass(right); resulttypepass(right);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
if not is_boolean(left.resulttype.def) then if not is_boolean(left.resulttype.def) then
@ -543,7 +543,7 @@ implementation
{ else path } { else path }
if assigned(t1) then if assigned(t1) then
resulttypepass(t1); resulttypepass(t1);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -699,7 +699,7 @@ implementation
t2:=tassignmentnode(left).left.getcopy; t2:=tassignmentnode(left).left.getcopy;
resulttypepass(left); resulttypepass(left);
set_varstate(left,false); set_varstate(left,vs_used,true);
if assigned(t1) then if assigned(t1) then
begin begin
@ -710,7 +710,7 @@ implementation
{ process count var } { process count var }
resulttypepass(t2); resulttypepass(t2);
set_varstate(t2,true); set_varstate(t2,vs_used,false);
if codegenerror then if codegenerror then
exit; exit;
@ -749,7 +749,7 @@ implementation
CGMessagePos(hp.fileinfo,cg_e_illegal_count_var); CGMessagePos(hp.fileinfo,cg_e_illegal_count_var);
resulttypepass(right); resulttypepass(right);
set_varstate(right,true); set_varstate(right,vs_used,true);
inserttypeconv(right,t2.resulttype); inserttypeconv(right,t2.resulttype);
end; end;
@ -864,7 +864,7 @@ implementation
cloadnode.create(current_procinfo.procdef.funcretsym,current_procinfo.procdef.funcretsym.owner), cloadnode.create(current_procinfo.procdef.funcretsym,current_procinfo.procdef.funcretsym.owner),
left); left);
resulttypepass(left); resulttypepass(left);
set_varstate(left,true); set_varstate(left,vs_used,true);
end; end;
resulttype:=voidtype; resulttype:=voidtype;
end; end;
@ -1166,7 +1166,7 @@ implementation
begin begin
{ first para must be a _class_ } { first para must be a _class_ }
resulttypepass(left); resulttypepass(left);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
if not(is_class(left.resulttype.def)) then if not(is_class(left.resulttype.def)) then
@ -1293,16 +1293,16 @@ implementation
resulttype:=voidtype; resulttype:=voidtype;
resulttypepass(left); resulttypepass(left);
set_varstate(left,true); set_varstate(left,vs_used,true);
resulttypepass(right); resulttypepass(right);
set_varstate(right,true); set_varstate(right,vs_used,true);
{ special finally block only executed when there was an exception } { special finally block only executed when there was an exception }
if assigned(t1) then if assigned(t1) then
begin begin
resulttypepass(t1); resulttypepass(t1);
set_varstate(t1,true); set_varstate(t1,vs_used,true);
end; end;
end; end;
@ -1431,7 +1431,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.81 2003-10-05 11:53:57 florian Revision 1.82 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.81 2003/10/05 11:53:57 florian
* writing of loop nodes fixed * writing of loop nodes fixed
Revision 1.80 2003/10/01 20:34:48 peter Revision 1.80 2003/10/01 20:34:48 peter

54
compiler/ninl.pas
View File

@ -75,7 +75,7 @@ implementation
symbase,symconst,symtype,symdef,symsym,symtable,paramgr,defutil,defcmp, symbase,symconst,symtype,symdef,symsym,symtable,paramgr,defutil,defcmp,
pass_1, pass_1,
ncal,ncon,ncnv,nadd,nld,nbas,nflw,nmem,nmat, ncal,ncon,ncnv,nadd,nld,nbas,nflw,nmem,nmat,
cpubase,cgbase,procinfo cgbase,procinfo
; ;
function geninlinenode(number : byte;is_const:boolean;l : tnode) : tinlinenode; function geninlinenode(number : byte;is_const:boolean;l : tnode) : tinlinenode;
@ -397,7 +397,7 @@ implementation
left := filepara.right; left := filepara.right;
filepara.right := nil; filepara.right := nil;
{ the file para is a var parameter, but it must be valid already } { the file para is a var parameter, but it must be valid already }
set_varstate(filepara,true); set_varstate(filepara.left,vs_used,true);
{ check if we should make a temp to store the result of a complex } { check if we should make a temp to store the result of a complex }
{ expression (better heuristics, anyone?) (JM) } { expression (better heuristics, anyone?) (JM) }
if (filepara.left.nodetype <> loadn) then if (filepara.left.nodetype <> loadn) then
@ -1380,7 +1380,7 @@ implementation
result:=hp; result:=hp;
goto myexit; goto myexit;
end; end;
set_varstate(left,true); set_varstate(left,vs_used,true);
if not is_integer(left.resulttype.def) then if not is_integer(left.resulttype.def) then
CGMessage(type_e_mismatch); CGMessage(type_e_mismatch);
case inlinenumber of case inlinenumber of
@ -1399,7 +1399,7 @@ implementation
in_sizeof_x: in_sizeof_x:
begin begin
set_varstate(left,false); set_varstate(left,vs_used,false);
if paramanager.push_high_param(vs_value,left.resulttype.def,current_procinfo.procdef.proccalloption) then if paramanager.push_high_param(vs_value,left.resulttype.def,current_procinfo.procdef.proccalloption) then
begin begin
hightree:=load_high_value_node(tvarsym(tloadnode(left).symtableentry)); hightree:=load_high_value_node(tvarsym(tloadnode(left).symtableentry));
@ -1420,7 +1420,7 @@ implementation
in_typeof_x: in_typeof_x:
begin begin
set_varstate(left,false); set_varstate(left,vs_used,false);
resulttype:=voidpointertype; resulttype:=voidpointertype;
end; end;
@ -1433,7 +1433,7 @@ implementation
result:=hp; result:=hp;
goto myexit; goto myexit;
end; end;
set_varstate(left,true); set_varstate(left,vs_used,true);
case left.resulttype.def.deftype of case left.resulttype.def.deftype of
orddef : orddef :
begin begin
@ -1486,7 +1486,7 @@ implementation
in_chr_byte: in_chr_byte:
begin begin
{ convert to explicit char() } { convert to explicit char() }
set_varstate(left,true); set_varstate(left,vs_used,true);
hp:=ctypeconvnode.create_explicit(left,cchartype); hp:=ctypeconvnode.create_explicit(left,cchartype);
left:=nil; left:=nil;
result:=hp; result:=hp;
@ -1494,7 +1494,7 @@ implementation
in_length_x: in_length_x:
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
case left.resulttype.def.deftype of case left.resulttype.def.deftype of
stringdef : stringdef :
@ -1601,7 +1601,7 @@ implementation
in_typeinfo_x: in_typeinfo_x:
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
resulttype:=voidpointertype; resulttype:=voidpointertype;
end; end;
@ -1622,7 +1622,7 @@ implementation
in_seg_x : in_seg_x :
begin begin
set_varstate(left,false); set_varstate(left,vs_used,false);
hp:=cordconstnode.create(0,s32bittype,false); hp:=cordconstnode.create(0,s32bittype,false);
result:=hp; result:=hp;
goto myexit; goto myexit;
@ -1631,7 +1631,7 @@ implementation
in_pred_x, in_pred_x,
in_succ_x: in_succ_x:
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
resulttype:=left.resulttype; resulttype:=left.resulttype;
if not is_ordinal(resulttype.def) then if not is_ordinal(resulttype.def) then
CGMessage(type_e_ordinal_expr_expected) CGMessage(type_e_ordinal_expr_expected)
@ -1672,11 +1672,9 @@ implementation
resulttype:=voidtype; resulttype:=voidtype;
if assigned(left) then if assigned(left) then
begin begin
set_varstate(left,true);
if codegenerror then
exit;
{ first param must be var } { first param must be var }
valid_for_var(tcallparanode(left).left); valid_for_var(tcallparanode(left).left);
set_varstate(tcallparanode(left).left,vs_used,true);
if (left.resulttype.def.deftype in [enumdef,pointerdef]) or if (left.resulttype.def.deftype in [enumdef,pointerdef]) or
is_ordinal(left.resulttype.def) or is_ordinal(left.resulttype.def) or
@ -1687,6 +1685,7 @@ implementation
{ two paras ? } { two paras ? }
if assigned(tcallparanode(left).right) then if assigned(tcallparanode(left).right) then
begin begin
set_varstate(tcallparanode(tcallparanode(left).right).left,vs_used,true);
if (aktlocalswitches * if (aktlocalswitches *
[cs_check_overflow,cs_check_range] = []) then [cs_check_overflow,cs_check_range] = []) then
begin begin
@ -1761,14 +1760,15 @@ implementation
resulttype:=voidtype; resulttype:=voidtype;
{ the parser already checks whether we have two (and exectly two) } { the parser already checks whether we have two (and exectly two) }
{ parameters (JM) } { parameters (JM) }
set_varstate(left,true);
{ first param must be var } { first param must be var }
valid_for_var(tcallparanode(left).left); valid_for_var(tcallparanode(left).left);
set_varstate(tcallparanode(left).left,vs_used,true);
{ check type } { check type }
if (left.resulttype.def.deftype=setdef) then if (left.resulttype.def.deftype=setdef) then
begin begin
{ insert a type conversion } { insert a type conversion }
{ to the type of the set elements } { to the type of the set elements }
set_varstate(tcallparanode(tcallparanode(left).right).left,vs_used,true);
inserttypeconv(tcallparanode(tcallparanode(left).right).left, inserttypeconv(tcallparanode(tcallparanode(left).right).left,
tsetdef(left.resulttype.def).elementtype); tsetdef(left.resulttype.def).elementtype);
end end
@ -1779,7 +1779,7 @@ implementation
in_low_x, in_low_x,
in_high_x: in_high_x:
begin begin
set_varstate(left,false); set_varstate(left,vs_used,false);
case left.resulttype.def.deftype of case left.resulttype.def.deftype of
orddef, orddef,
enumdef: enumdef:
@ -1854,7 +1854,7 @@ implementation
setconstrealvalue(cos(getconstrealvalue)) setconstrealvalue(cos(getconstrealvalue))
else else
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
inserttypeconv(left,pbestrealtype^); inserttypeconv(left,pbestrealtype^);
resulttype:=pbestrealtype^; resulttype:=pbestrealtype^;
end; end;
@ -1866,7 +1866,7 @@ implementation
setconstrealvalue(sin(getconstrealvalue)) setconstrealvalue(sin(getconstrealvalue))
else else
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
inserttypeconv(left,pbestrealtype^); inserttypeconv(left,pbestrealtype^);
resulttype:=pbestrealtype^; resulttype:=pbestrealtype^;
end; end;
@ -1878,7 +1878,7 @@ implementation
setconstrealvalue(arctan(getconstrealvalue)) setconstrealvalue(arctan(getconstrealvalue))
else else
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
inserttypeconv(left,pbestrealtype^); inserttypeconv(left,pbestrealtype^);
resulttype:=pbestrealtype^; resulttype:=pbestrealtype^;
end; end;
@ -1890,7 +1890,7 @@ implementation
setconstrealvalue(abs(getconstrealvalue)) setconstrealvalue(abs(getconstrealvalue))
else else
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
inserttypeconv(left,pbestrealtype^); inserttypeconv(left,pbestrealtype^);
resulttype:=pbestrealtype^; resulttype:=pbestrealtype^;
end; end;
@ -1902,7 +1902,7 @@ implementation
setconstrealvalue(sqr(getconstrealvalue)) setconstrealvalue(sqr(getconstrealvalue))
else else
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
inserttypeconv(left,pbestrealtype^); inserttypeconv(left,pbestrealtype^);
resulttype:=pbestrealtype^; resulttype:=pbestrealtype^;
end; end;
@ -1920,7 +1920,7 @@ implementation
end end
else else
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
inserttypeconv(left,pbestrealtype^); inserttypeconv(left,pbestrealtype^);
resulttype:=pbestrealtype^; resulttype:=pbestrealtype^;
end; end;
@ -1938,7 +1938,7 @@ implementation
end end
else else
begin begin
set_varstate(left,true); set_varstate(left,vs_used,true);
inserttypeconv(left,pbestrealtype^); inserttypeconv(left,pbestrealtype^);
resulttype:=pbestrealtype^; resulttype:=pbestrealtype^;
end; end;
@ -1955,10 +1955,11 @@ implementation
resulttype:=voidtype; resulttype:=voidtype;
if assigned(left) then if assigned(left) then
begin begin
set_varstate(left,true); set_varstate(tcallparanode(left).left,vs_used,true);
{ check type } { check type }
if is_boolean(left.resulttype.def) then if is_boolean(left.resulttype.def) then
begin begin
set_varstate(tcallparanode(tcallparanode(left).right).left,vs_used,true);
{ must always be a string } { must always be a string }
inserttypeconv(tcallparanode(tcallparanode(left).right).left,cshortstringtype); inserttypeconv(tcallparanode(tcallparanode(left).right).left,cshortstringtype);
end end
@ -2357,7 +2358,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.119 2003-10-01 20:34:48 peter Revision 1.120 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.119 2003/10/01 20:34:48 peter
* procinfo unit contains tprocinfo * procinfo unit contains tprocinfo
* cginfo renamed to cgbase * cginfo renamed to cgbase
* moved cgmessage to verbose * moved cgmessage to verbose

16
compiler/nld.pas
View File

@ -657,9 +657,8 @@ implementation
end; end;
resulttypepass(right); resulttypepass(right);
set_varstate(left,false); set_varstate(left,vs_assigned,false);
set_varstate(right,true); set_varstate(right,vs_used,true);
{ set_funcret_is_valid(left); }
if codegenerror then if codegenerror then
exit; exit;
@ -894,8 +893,8 @@ implementation
result:=nil; result:=nil;
resulttypepass(left); resulttypepass(left);
resulttypepass(right); resulttypepass(right);
set_varstate(left,true); set_varstate(left,vs_used,true);
set_varstate(right,true); set_varstate(right,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
resulttype:=left.resulttype; resulttype:=left.resulttype;
@ -959,7 +958,7 @@ implementation
while assigned(hp) do while assigned(hp) do
begin begin
resulttypepass(hp.left); resulttypepass(hp.left);
set_varstate(hp.left,true); set_varstate(hp.left,vs_used,true);
if (htype.def=nil) then if (htype.def=nil) then
htype:=hp.left.resulttype htype:=hp.left.resulttype
else else
@ -1247,7 +1246,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.109 2003-10-05 21:21:52 peter Revision 1.110 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.109 2003/10/05 21:21:52 peter
* c style array of const generates callparanodes * c style array of const generates callparanodes
* varargs paraloc fixes * varargs paraloc fixes

17
compiler/nmat.pas
View File

@ -102,8 +102,8 @@ implementation
result:=nil; result:=nil;
resulttypepass(left); resulttypepass(left);
resulttypepass(right); resulttypepass(right);
set_varstate(left,true); set_varstate(left,vs_used,true);
set_varstate(right,true); set_varstate(right,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -431,8 +431,8 @@ implementation
result:=nil; result:=nil;
resulttypepass(left); resulttypepass(left);
resulttypepass(right); resulttypepass(right);
set_varstate(right,true); set_varstate(right,vs_used,true);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -516,7 +516,7 @@ implementation
begin begin
result:=nil; result:=nil;
resulttypepass(left); resulttypepass(left);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -649,7 +649,7 @@ implementation
begin begin
result:=nil; result:=nil;
resulttypepass(left); resulttypepass(left);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -831,7 +831,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.52 2003-10-01 20:34:49 peter Revision 1.53 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.52 2003/10/01 20:34:49 peter
* procinfo unit contains tprocinfo * procinfo unit contains tprocinfo
* cginfo renamed to cgbase * cginfo renamed to cgbase
* moved cgmessage to verbose * moved cgmessage to verbose

13
compiler/nmem.pas
View File

@ -401,7 +401,7 @@ implementation
{ this is like the function addr } { this is like the function addr }
inc(parsing_para_level); inc(parsing_para_level);
set_varstate(left,false); set_varstate(left,vs_used,false);
dec(parsing_para_level); dec(parsing_para_level);
end; end;
@ -462,7 +462,7 @@ implementation
begin begin
result:=nil; result:=nil;
resulttypepass(left); resulttypepass(left);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -842,8 +842,8 @@ implementation
resulttype:=voidtype; resulttype:=voidtype;
resulttypepass(withrefnode); resulttypepass(withrefnode);
unset_varstate(withrefnode); //unset_varstate(withrefnode);
set_varstate(withrefnode,true); set_varstate(withrefnode,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -904,7 +904,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.64 2003-10-01 20:34:49 peter Revision 1.65 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.64 2003/10/01 20:34:49 peter
* procinfo unit contains tprocinfo * procinfo unit contains tprocinfo
* cginfo renamed to cgbase * cginfo renamed to cgbase
* moved cgmessage to verbose * moved cgmessage to verbose

6
compiler/node.pas
View File

@ -201,7 +201,6 @@ interface
{ general } { general }
nf_write, { Node is written to } nf_write, { Node is written to }
nf_first_use, { First node that uses a variable after declared }
nf_varstateset, nf_varstateset,
nf_isproperty, nf_isproperty,
@ -977,7 +976,10 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.68 2003-10-01 20:34:49 peter Revision 1.69 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.68 2003/10/01 20:34:49 peter
* procinfo unit contains tprocinfo * procinfo unit contains tprocinfo
* cginfo renamed to cgbase * cginfo renamed to cgbase
* moved cgmessage to verbose * moved cgmessage to verbose

19
compiler/nset.pas
View File

@ -118,7 +118,7 @@ implementation
verbose, verbose,
symconst,symdef,symsym,defutil,defcmp, symconst,symdef,symsym,defutil,defcmp,
htypechk,pass_1, htypechk,pass_1,
nbas,ncnv,ncon,cpubase,nld,rgobj,cgbase; nbas,ncnv,ncon,nld,rgobj,cgbase;
function gencasenode(l,r : tnode;nodes : pcaserecord) : tnode; function gencasenode(l,r : tnode;nodes : pcaserecord) : tnode;
@ -147,7 +147,7 @@ implementation
resulttypepass(left); resulttypepass(left);
if assigned(right) then if assigned(right) then
resulttypepass(right); resulttypepass(right);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -216,7 +216,7 @@ implementation
result:=nil; result:=nil;
resulttype:=booltype; resulttype:=booltype;
resulttypepass(right); resulttypepass(right);
set_varstate(right,true); set_varstate(right,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -243,7 +243,7 @@ implementation
end; end;
resulttypepass(left); resulttypepass(left);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
@ -341,8 +341,8 @@ implementation
result:=nil; result:=nil;
resulttypepass(left); resulttypepass(left);
resulttypepass(right); resulttypepass(right);
set_varstate(left,true); set_varstate(left,vs_used,true);
set_varstate(right,true); set_varstate(right,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
{ both types must be compatible } { both types must be compatible }
@ -572,7 +572,7 @@ implementation
expectloc:=LOC_VOID; expectloc:=LOC_VOID;
{ evalutes the case expression } { evalutes the case expression }
firstpass(left); firstpass(left);
set_varstate(left,true); set_varstate(left,vs_used,true);
if codegenerror then if codegenerror then
exit; exit;
registers32:=left.registers32; registers32:=left.registers32;
@ -686,7 +686,10 @@ begin
end. end.
{ {
$Log$ $Log$
Revision 1.45 2003-10-01 20:34:49 peter Revision 1.46 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.45 2003/10/01 20:34:49 peter
* procinfo unit contains tprocinfo * procinfo unit contains tprocinfo
* cginfo renamed to cgbase * cginfo renamed to cgbase
* moved cgmessage to verbose * moved cgmessage to verbose

17
compiler/pexpr.pas
View File

@ -366,8 +366,7 @@ implementation
Message(parser_e_illegal_parameter_list); Message(parser_e_illegal_parameter_list);
end; end;
consume(_RKLAMMER); consume(_RKLAMMER);
p2:=ccallparanode.create(p1,nil); p2:=geninlinenode(in_typeinfo_x,false,p1);
p2:=geninlinenode(in_typeinfo_x,false,p2);
statement_syssym:=p2; statement_syssym:=p2;
end; end;
@ -511,7 +510,7 @@ implementation
while true do while true do
begin begin
p1:=comp_expr(true); p1:=comp_expr(true);
set_varstate(p1,true); set_varstate(p1,vs_used,true);
if not((p1.resulttype.def.deftype=stringdef) or if not((p1.resulttype.def.deftype=stringdef) or
((p1.resulttype.def.deftype=orddef) and ((p1.resulttype.def.deftype=orddef) and
(torddef(p1.resulttype.def).typ=uchar))) then (torddef(p1.resulttype.def).typ=uchar))) then
@ -1194,13 +1193,6 @@ implementation
else else
p1:=cloadnode.create(srsym,srsymtable); p1:=cloadnode.create(srsym,srsymtable);
end; end;
if tvarsym(srsym).varstate=vs_declared then
begin
include(p1.flags,nf_first_use);
{ set special between first loaded until checked in resulttypepass }
tvarsym(srsym).varstate:=vs_declared_and_first_found;
end;
end; end;
typedconstsym : typedconstsym :
@ -2425,7 +2417,10 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.132 2003-10-05 12:56:04 peter Revision 1.133 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.132 2003/10/05 12:56:04 peter
* fix assigned(property) * fix assigned(property)
Revision 1.131 2003/10/02 21:15:31 peter Revision 1.131 2003/10/02 21:15:31 peter

14
compiler/pinline.pas
View File

@ -81,7 +81,10 @@ implementation
consume(_LKLAMMER); consume(_LKLAMMER);
p:=comp_expr(true); p:=comp_expr(true);
{ calc return type } { calc return type }
set_varstate(p,(not is_new)); if is_new then
set_varstate(p,vs_assigned,false)
else
set_varstate(p,vs_used,true);
{ constructor,destructor specified } { constructor,destructor specified }
if try_to_consume(_COMMA) then if try_to_consume(_COMMA) then
begin begin
@ -415,7 +418,7 @@ implementation
ppn:=tcallparanode(paras); ppn:=tcallparanode(paras);
while assigned(ppn.right) do while assigned(ppn.right) do
begin begin
set_varstate(ppn.left,true); set_varstate(ppn.left,vs_used,true);
inserttypeconv(ppn.left,s32bittype); inserttypeconv(ppn.left,s32bittype);
inc(counter); inc(counter);
ppn:=tcallparanode(ppn.right); ppn:=tcallparanode(ppn.right);
@ -431,7 +434,7 @@ implementation
destppn:=ppn.left; destppn:=ppn.left;
inc(parsing_para_level); inc(parsing_para_level);
valid_for_var(destppn); valid_for_var(destppn);
set_varstate(destppn,false); set_varstate(destppn,vs_assigned,false);
dec(parsing_para_level); dec(parsing_para_level);
{ first param must be a string or dynamic array ...} { first param must be a string or dynamic array ...}
isarray:=is_dynamic_array(destppn.resulttype.def); isarray:=is_dynamic_array(destppn.resulttype.def);
@ -685,7 +688,10 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.20 2003-10-02 21:15:31 peter Revision 1.21 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.20 2003/10/02 21:15:31 peter
* protected visibility fixes * protected visibility fixes
Revision 1.19 2003/10/01 20:34:49 peter Revision 1.19 2003/10/01 20:34:49 peter

8
compiler/pstatmnt.pas
View File

@ -188,6 +188,7 @@ implementation
caseexpr:=comp_expr(true); caseexpr:=comp_expr(true);
{ determines result type } { determines result type }
do_resulttypepass(caseexpr); do_resulttypepass(caseexpr);
set_varstate(caseexpr,vs_used,true);
casedeferror:=false; casedeferror:=false;
casedef:=caseexpr.resulttype.def; casedef:=caseexpr.resulttype.def;
if (not assigned(casedef)) or if (not assigned(casedef)) or
@ -392,7 +393,7 @@ implementation
begin begin
p:=comp_expr(true); p:=comp_expr(true);
do_resulttypepass(p); do_resulttypepass(p);
set_varstate(p,false); set_varstate(p,vs_used,false);
right:=nil; right:=nil;
if (not codegenerror) and if (not codegenerror) and
(p.resulttype.def.deftype in [objectdef,recorddef]) then (p.resulttype.def.deftype in [objectdef,recorddef]) then
@ -1128,7 +1129,10 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.113 2003-10-07 20:06:37 peter Revision 1.114 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.113 2003/10/07 20:06:37 peter
* set calling convention before assembler block is parsed * set calling convention before assembler block is parsed
Revision 1.112 2003/10/02 21:15:59 peter Revision 1.112 2003/10/02 21:15:59 peter

8
compiler/symconst.pas
View File

@ -288,8 +288,7 @@ type
{ State of the variable, if it's declared, assigned or used } { State of the variable, if it's declared, assigned or used }
tvarstate=(vs_none, tvarstate=(vs_none,
vs_declared,vs_declared_and_first_found, vs_declared,vs_assigned,vs_used
vs_set_but_first_not_passed,vs_assigned,vs_used
); );
tvarspez = (vs_value,vs_const,vs_var,vs_out); tvarspez = (vs_value,vs_const,vs_var,vs_out);
@ -377,7 +376,10 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.67 2003-10-07 15:17:07 peter Revision 1.68 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.67 2003/10/07 15:17:07 peter
* inline supported again, LOC_REFERENCEs are used to pass the * inline supported again, LOC_REFERENCEs are used to pass the
parameters parameters
* inlineparasymtable,inlinelocalsymtable removed * inlineparasymtable,inlinelocalsymtable removed

7
compiler/symsym.pas
View File

@ -1643,7 +1643,7 @@ implementation
highvarsym:=nil; highvarsym:=nil;
defaultconstsym:=nil; defaultconstsym:=nil;
refs:=0; refs:=0;
varstate:=vs_used; varstate:=vs_declared;
varoptions:=[]; varoptions:=[];
end; end;
@ -2676,7 +2676,10 @@ implementation
end. end.
{ {
$Log$ $Log$
Revision 1.124 2003-10-07 21:14:33 peter Revision 1.125 2003-10-08 19:19:45 peter
* set_varstate cleanup
Revision 1.124 2003/10/07 21:14:33 peter
* compare_paras() has a parameter to ignore hidden parameters * compare_paras() has a parameter to ignore hidden parameters
* cross unit overload searching ignores hidden parameters when * cross unit overload searching ignores hidden parameters when
comparing parameter lists. Now function(string):string is comparing parameter lists. Now function(string):string is