mirror of
https://gitlab.com/freepascal.org/fpc/source.git
synced 2025-05-01 08:33:46 +02:00
1272 lines
50 KiB
ObjectPascal
1272 lines
50 KiB
ObjectPascal
{
|
|
$Id$
|
|
Copyright (c) 1998-2000 by Florian Klaempfl
|
|
|
|
Type checking and register allocation for add nodes
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; if not, write to the Free Software
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
****************************************************************************
|
|
}
|
|
unit nadd;
|
|
|
|
{$i defines.inc}
|
|
|
|
interface
|
|
|
|
uses
|
|
node;
|
|
|
|
type
|
|
taddnode = class(tbinopnode)
|
|
procedure make_bool_equal_size;
|
|
function pass_1 : tnode;override;
|
|
end;
|
|
|
|
var
|
|
{ caddnode is used to create nodes of the add type }
|
|
{ the virtual constructor allows to assign }
|
|
{ another class type to caddnode => processor }
|
|
{ specific node types can be created }
|
|
caddnode : class of taddnode;
|
|
|
|
implementation
|
|
|
|
uses
|
|
globtype,systems,tokens,
|
|
cobjects,cutils,verbose,globals,
|
|
symconst,symtable,aasm,types,
|
|
cpuinfo,
|
|
{$ifdef newcg}
|
|
cgbase,
|
|
{$else newcg}
|
|
hcodegen,
|
|
{$endif newcg}
|
|
htypechk,pass_1,
|
|
ncal,nmat,ncnv,nld,ncon,nset,
|
|
cpubase;
|
|
|
|
|
|
{*****************************************************************************
|
|
TADDNODE
|
|
*****************************************************************************}
|
|
|
|
{$ifdef fpc}
|
|
{$maxfpuregisters 0}
|
|
{$endif fpc}
|
|
|
|
procedure taddnode.make_bool_equal_size;
|
|
|
|
begin
|
|
if porddef(left.resulttype)^.typ>porddef(right.resulttype)^.typ then
|
|
begin
|
|
right:=gentypeconvnode(right,porddef(left.resulttype));
|
|
ttypeconvnode(right).convtype:=tc_bool_2_int;
|
|
include(right.flags,nf_explizit);
|
|
firstpass(right);
|
|
end
|
|
else
|
|
if porddef(left.resulttype)^.typ<porddef(right.resulttype)^.typ then
|
|
begin
|
|
left:=gentypeconvnode(left,porddef(right.resulttype));
|
|
ttypeconvnode(left).convtype:=tc_bool_2_int;
|
|
include(left.flags,nf_explizit);
|
|
firstpass(left);
|
|
end;
|
|
end;
|
|
|
|
function taddnode.pass_1 : tnode;
|
|
|
|
var
|
|
t,hp : tnode;
|
|
ot,
|
|
lt,rt : tnodetype;
|
|
rv,lv : longint;
|
|
rvd,lvd : bestreal;
|
|
resdef,
|
|
rd,ld : pdef;
|
|
tempdef : pdef;
|
|
concatstrings : boolean;
|
|
|
|
{ to evalute const sets }
|
|
resultset : pconstset;
|
|
i : longint;
|
|
b : boolean;
|
|
convdone : boolean;
|
|
s1,s2 : pchar;
|
|
l1,l2 : longint;
|
|
|
|
begin
|
|
pass_1:=nil;
|
|
{ first do the two subtrees }
|
|
firstpass(left);
|
|
firstpass(right);
|
|
if codegenerror then
|
|
exit;
|
|
|
|
{ convert array constructors to sets, because there is no other operator
|
|
possible for array constructors }
|
|
if is_array_constructor(left.resulttype) then
|
|
arrayconstructor_to_set(tarrayconstructnode(left));
|
|
if is_array_constructor(right.resulttype) then
|
|
arrayconstructor_to_set(tarrayconstructnode(right));
|
|
|
|
{ both left and right need to be valid }
|
|
set_varstate(left,true);
|
|
set_varstate(right,true);
|
|
|
|
{ load easier access variables }
|
|
lt:=left.nodetype;
|
|
rt:=right.nodetype;
|
|
rd:=right.resulttype;
|
|
ld:=left.resulttype;
|
|
convdone:=false;
|
|
|
|
hp:=self;
|
|
if isbinaryoverloaded(hp) then
|
|
begin
|
|
pass_1:=hp;
|
|
exit;
|
|
end;
|
|
{ compact consts }
|
|
|
|
{ convert int consts to real consts, if the }
|
|
{ other operand is a real const }
|
|
if (rt=realconstn) and is_constintnode(left) then
|
|
begin
|
|
t:=genrealconstnode(tordconstnode(left).value,right.resulttype);
|
|
left.free;
|
|
left:=t;
|
|
lt:=realconstn;
|
|
end;
|
|
if (lt=realconstn) and is_constintnode(right) then
|
|
begin
|
|
t:=genrealconstnode(tordconstnode(right).value,left.resulttype);
|
|
right.free;
|
|
right:=t;
|
|
rt:=realconstn;
|
|
end;
|
|
|
|
{ both are int constants, also allow operations on two equal enums
|
|
in fpc mode (Needed for conversion of C code) }
|
|
if ((lt=ordconstn) and (rt=ordconstn)) and
|
|
((is_constintnode(left) and is_constintnode(right)) or
|
|
(is_constboolnode(left) and is_constboolnode(right) and
|
|
(nodetype in [ltn,lten,gtn,gten,equaln,unequaln,andn,xorn,orn]))) then
|
|
begin
|
|
{ xor, and, or are handled different from arithmetic }
|
|
{ operations regarding the result type }
|
|
{ return a boolean for boolean operations (and,xor,or) }
|
|
if is_constboolnode(left) then
|
|
resdef:=booldef
|
|
else if is_64bitint(rd) or is_64bitint(ld) then
|
|
resdef:=cs64bitdef
|
|
else
|
|
resdef:=s32bitdef;
|
|
lv:=tordconstnode(left).value;
|
|
rv:=tordconstnode(right).value;
|
|
case nodetype of
|
|
addn : t:=genintconstnode(lv+rv);
|
|
subn : t:=genintconstnode(lv-rv);
|
|
muln : t:=genintconstnode(lv*rv);
|
|
xorn : t:=genordinalconstnode(lv xor rv,resdef);
|
|
orn: t:=genordinalconstnode(lv or rv,resdef);
|
|
andn: t:=genordinalconstnode(lv and rv,resdef);
|
|
ltn : t:=genordinalconstnode(ord(lv<rv),booldef);
|
|
lten : t:=genordinalconstnode(ord(lv<=rv),booldef);
|
|
gtn : t:=genordinalconstnode(ord(lv>rv),booldef);
|
|
gten : t:=genordinalconstnode(ord(lv>=rv),booldef);
|
|
equaln : t:=genordinalconstnode(ord(lv=rv),booldef);
|
|
unequaln : t:=genordinalconstnode(ord(lv<>rv),booldef);
|
|
slashn : begin
|
|
{ int/int becomes a real }
|
|
if int(rv)=0 then
|
|
begin
|
|
Message(parser_e_invalid_float_operation);
|
|
t:=genrealconstnode(0,bestrealdef^);
|
|
end
|
|
else
|
|
t:=genrealconstnode(int(lv)/int(rv),bestrealdef^);
|
|
firstpass(t);
|
|
end;
|
|
else
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
pass_1:=t;
|
|
exit;
|
|
end;
|
|
|
|
{ both real constants ? }
|
|
if (lt=realconstn) and (rt=realconstn) then
|
|
begin
|
|
lvd:=trealconstnode(left).value_real;
|
|
rvd:=trealconstnode(right).value_real;
|
|
case nodetype of
|
|
addn : t:=genrealconstnode(lvd+rvd,bestrealdef^);
|
|
subn : t:=genrealconstnode(lvd-rvd,bestrealdef^);
|
|
muln : t:=genrealconstnode(lvd*rvd,bestrealdef^);
|
|
starstarn,
|
|
caretn : begin
|
|
if lvd<0 then
|
|
begin
|
|
Message(parser_e_invalid_float_operation);
|
|
t:=genrealconstnode(0,bestrealdef^);
|
|
end
|
|
else if lvd=0 then
|
|
t:=genrealconstnode(1.0,bestrealdef^)
|
|
else
|
|
t:=genrealconstnode(exp(ln(lvd)*rvd),bestrealdef^);
|
|
end;
|
|
slashn :
|
|
begin
|
|
if rvd=0 then
|
|
begin
|
|
Message(parser_e_invalid_float_operation);
|
|
t:=genrealconstnode(0,bestrealdef^);
|
|
end
|
|
else
|
|
t:=genrealconstnode(lvd/rvd,bestrealdef^);
|
|
end;
|
|
ltn : t:=genordinalconstnode(ord(lvd<rvd),booldef);
|
|
lten : t:=genordinalconstnode(ord(lvd<=rvd),booldef);
|
|
gtn : t:=genordinalconstnode(ord(lvd>rvd),booldef);
|
|
gten : t:=genordinalconstnode(ord(lvd>=rvd),booldef);
|
|
equaln : t:=genordinalconstnode(ord(lvd=rvd),booldef);
|
|
unequaln : t:=genordinalconstnode(ord(lvd<>rvd),booldef);
|
|
else
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
pass_1:=t;
|
|
exit;
|
|
end;
|
|
|
|
{ concating strings ? }
|
|
concatstrings:=false;
|
|
s1:=nil;
|
|
s2:=nil;
|
|
if (lt=ordconstn) and (rt=ordconstn) and
|
|
is_char(ld) and is_char(rd) then
|
|
begin
|
|
s1:=strpnew(char(byte(tordconstnode(left).value)));
|
|
s2:=strpnew(char(byte(tordconstnode(right).value)));
|
|
l1:=1;
|
|
l2:=1;
|
|
concatstrings:=true;
|
|
end
|
|
else
|
|
if (lt=stringconstn) and (rt=ordconstn) and is_char(rd) then
|
|
begin
|
|
s1:=tstringconstnode(left).getpcharcopy;
|
|
l1:=tstringconstnode(left).len;
|
|
s2:=strpnew(char(byte(tordconstnode(right).value)));
|
|
l2:=1;
|
|
concatstrings:=true;
|
|
end
|
|
else
|
|
if (lt=ordconstn) and (rt=stringconstn) and is_char(ld) then
|
|
begin
|
|
s1:=strpnew(char(byte(tordconstnode(left).value)));
|
|
l1:=1;
|
|
s2:=tstringconstnode(right).getpcharcopy;
|
|
l2:=tstringconstnode(right).len;
|
|
concatstrings:=true;
|
|
end
|
|
else if (lt=stringconstn) and (rt=stringconstn) then
|
|
begin
|
|
s1:=tstringconstnode(left).getpcharcopy;
|
|
l1:=tstringconstnode(left).len;
|
|
s2:=tstringconstnode(right).getpcharcopy;
|
|
l2:=tstringconstnode(right).len;
|
|
concatstrings:=true;
|
|
end;
|
|
|
|
{ I will need to translate all this to ansistrings !!! }
|
|
if concatstrings then
|
|
begin
|
|
case nodetype of
|
|
addn :
|
|
t:=genpcharconstnode(concatansistrings(s1,s2,l1,l2),l1+l2);
|
|
ltn :
|
|
t:=genordinalconstnode(byte(compareansistrings(s1,s2,l1,l2)<0),booldef);
|
|
lten :
|
|
t:=genordinalconstnode(byte(compareansistrings(s1,s2,l1,l2)<=0),booldef);
|
|
gtn :
|
|
t:=genordinalconstnode(byte(compareansistrings(s1,s2,l1,l2)>0),booldef);
|
|
gten :
|
|
t:=genordinalconstnode(byte(compareansistrings(s1,s2,l1,l2)>=0),booldef);
|
|
equaln :
|
|
t:=genordinalconstnode(byte(compareansistrings(s1,s2,l1,l2)=0),booldef);
|
|
unequaln :
|
|
t:=genordinalconstnode(byte(compareansistrings(s1,s2,l1,l2)<>0),booldef);
|
|
end;
|
|
ansistringdispose(s1,l1);
|
|
ansistringdispose(s2,l2);
|
|
pass_1:=t;
|
|
exit;
|
|
end;
|
|
|
|
{ if both are orddefs then check sub types }
|
|
if (ld^.deftype=orddef) and (rd^.deftype=orddef) then
|
|
begin
|
|
{ 2 booleans ? }
|
|
if is_boolean(ld) and is_boolean(rd) then
|
|
begin
|
|
if (cs_full_boolean_eval in aktlocalswitches) or
|
|
(nodetype in [xorn,ltn,lten,gtn,gten]) then
|
|
begin
|
|
make_bool_equal_size;
|
|
if (left.location.loc in [LOC_JUMP,LOC_FLAGS]) and
|
|
(left.location.loc in [LOC_JUMP,LOC_FLAGS]) then
|
|
calcregisters(self,2,0,0)
|
|
else
|
|
calcregisters(self,1,0,0);
|
|
end
|
|
else
|
|
case nodetype of
|
|
andn,
|
|
orn:
|
|
begin
|
|
make_bool_equal_size;
|
|
calcregisters(self,0,0,0);
|
|
location.loc:=LOC_JUMP;
|
|
end;
|
|
unequaln,
|
|
equaln:
|
|
begin
|
|
make_bool_equal_size;
|
|
{ Remove any compares with constants }
|
|
if (left.nodetype=ordconstn) then
|
|
begin
|
|
hp:=right;
|
|
b:=(tordconstnode(left).value<>0);
|
|
ot:=nodetype;
|
|
left.free;
|
|
left:=nil;
|
|
right:=nil;
|
|
if (not(b) and (ot=equaln)) or
|
|
(b and (ot=unequaln)) then
|
|
begin
|
|
hp:=cnotnode.create(hp);
|
|
firstpass(hp);
|
|
end;
|
|
pass_1:=hp;
|
|
exit;
|
|
end;
|
|
if (right.nodetype=ordconstn) then
|
|
begin
|
|
hp:=left;
|
|
b:=(tordconstnode(right).value<>0);
|
|
ot:=nodetype;
|
|
right.free;
|
|
right:=nil;
|
|
left:=nil;
|
|
|
|
if (not(b) and (ot=equaln)) or
|
|
(b and (ot=unequaln)) then
|
|
begin
|
|
hp:=cnotnode.create(hp);
|
|
firstpass(hp);
|
|
end;
|
|
pass_1:=hp;
|
|
exit;
|
|
end;
|
|
if (left.location.loc in [LOC_JUMP,LOC_FLAGS]) and
|
|
(left.location.loc in [LOC_JUMP,LOC_FLAGS]) then
|
|
calcregisters(self,2,0,0)
|
|
else
|
|
calcregisters(self,1,0,0);
|
|
end;
|
|
else
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
(*
|
|
{ these one can't be in flags! }
|
|
|
|
Yes they can, secondadd converts the loc_flags to a register.
|
|
The typeconversions below are simply removed by firsttypeconv()
|
|
because the resulttype of left = left.resulttype
|
|
(surprise! :) (JM)
|
|
|
|
if nodetype in [xorn,unequaln,equaln] then
|
|
begin
|
|
if left.location.loc=LOC_FLAGS then
|
|
begin
|
|
left:=gentypeconvnode(left,porddef(left.resulttype));
|
|
left.convtype:=tc_bool_2_int;
|
|
left.explizit:=true;
|
|
firstpass(left);
|
|
end;
|
|
if right.location.loc=LOC_FLAGS then
|
|
begin
|
|
right:=gentypeconvnode(right,porddef(right.resulttype));
|
|
right.convtype:=tc_bool_2_int;
|
|
right.explizit:=true;
|
|
firstpass(right);
|
|
end;
|
|
{ readjust registers }
|
|
calcregisters(p,1,0,0);
|
|
end;
|
|
*)
|
|
convdone:=true;
|
|
end
|
|
else
|
|
{ Both are chars? only convert to shortstrings for addn }
|
|
if is_char(rd) and is_char(ld) then
|
|
begin
|
|
if nodetype=addn then
|
|
begin
|
|
left:=gentypeconvnode(left,cshortstringdef);
|
|
right:=gentypeconvnode(right,cshortstringdef);
|
|
firstpass(left);
|
|
firstpass(right);
|
|
{ here we call STRCOPY }
|
|
procinfo^.flags:=procinfo^.flags or pi_do_call;
|
|
calcregisters(self,0,0,0);
|
|
location.loc:=LOC_MEM;
|
|
end
|
|
else
|
|
calcregisters(self,1,0,0);
|
|
convdone:=true;
|
|
end
|
|
{ is there a 64 bit type ? }
|
|
else if ((porddef(rd)^.typ=s64bit) or (porddef(ld)^.typ=s64bit)) and
|
|
{ the / operator is handled later }
|
|
(nodetype<>slashn) then
|
|
begin
|
|
if (porddef(ld)^.typ<>s64bit) then
|
|
begin
|
|
left:=gentypeconvnode(left,cs64bitdef);
|
|
firstpass(left);
|
|
end;
|
|
if (porddef(rd)^.typ<>s64bit) then
|
|
begin
|
|
right:=gentypeconvnode(right,cs64bitdef);
|
|
firstpass(right);
|
|
end;
|
|
calcregisters(self,2,0,0);
|
|
convdone:=true;
|
|
end
|
|
else if ((porddef(rd)^.typ=u64bit) or (porddef(ld)^.typ=u64bit)) and
|
|
{ the / operator is handled later }
|
|
(nodetype<>slashn) then
|
|
begin
|
|
if (porddef(ld)^.typ<>u64bit) then
|
|
begin
|
|
left:=gentypeconvnode(left,cu64bitdef);
|
|
firstpass(left);
|
|
end;
|
|
if (porddef(rd)^.typ<>u64bit) then
|
|
begin
|
|
right:=gentypeconvnode(right,cu64bitdef);
|
|
firstpass(right);
|
|
end;
|
|
calcregisters(self,2,0,0);
|
|
convdone:=true;
|
|
end
|
|
else
|
|
{ is there a cardinal? }
|
|
if ((porddef(rd)^.typ=u32bit) or (porddef(ld)^.typ=u32bit)) and
|
|
{ the / operator is handled later }
|
|
(nodetype<>slashn) then
|
|
begin
|
|
{ convert constants to u32bit }
|
|
{$ifndef cardinalmulfix}
|
|
if (porddef(ld)^.typ<>u32bit) then
|
|
begin
|
|
{ s32bit will be used for when the other is also s32bit }
|
|
|
|
{ the following line doesn't make any sense: it's the same as }
|
|
{ if ((porddef(rd)^.typ=u32bit) or (porddef(ld)^.typ=u32bit)) and }
|
|
{ (porddef(ld)^.typ<>u32bit) and (porddef(rd)^.typ=s32bit) then }
|
|
{ which can be simplified to }
|
|
{ if ((porddef(rd)^.typ=u32bit) and (porddef(rd)^.typ=s32bit) then }
|
|
{ which can never be true (JM) }
|
|
if (porddef(rd)^.typ=s32bit) and (lt<>ordconstn) then
|
|
left:=gentypeconvnode(left,s32bitdef)
|
|
else
|
|
left:=gentypeconvnode(left,u32bitdef);
|
|
firstpass(left);
|
|
end;
|
|
if (porddef(rd)^.typ<>u32bit) then
|
|
begin
|
|
{ s32bit will be used for when the other is also s32bit }
|
|
if (porddef(ld)^.typ=s32bit) and (rt<>ordconstn) then
|
|
right:=gentypeconvnode(right,s32bitdef)
|
|
else
|
|
right:=gentypeconvnode(right,u32bitdef);
|
|
firstpass(right);
|
|
end;
|
|
{$else cardinalmulfix}
|
|
{ only do a conversion if the nodes have different signs }
|
|
if (porddef(rd)^.typ=u32bit) xor (porddef(ld)^.typ=u32bit) then
|
|
if (porddef(rd)^.typ=u32bit) then
|
|
begin
|
|
{ can we make them both unsigned? }
|
|
if (porddef(ld)^.typ in [u8bit,u16bit]) or
|
|
(is_constintnode(left) and
|
|
(nodetype <> subn) and
|
|
(left.value > 0)) then
|
|
left:=gentypeconvnode(left,u32bitdef)
|
|
else
|
|
left:=gentypeconvnode(left,s32bitdef);
|
|
firstpass(left);
|
|
end
|
|
else {if (porddef(ld)^.typ=u32bit) then}
|
|
begin
|
|
{ can we make them both unsigned? }
|
|
if (porddef(rd)^.typ in [u8bit,u16bit]) or
|
|
(is_constintnode(right) and
|
|
(right.value > 0)) then
|
|
right:=gentypeconvnode(right,u32bitdef)
|
|
else
|
|
right:=gentypeconvnode(right,s32bitdef);
|
|
firstpass(right);
|
|
end;
|
|
{$endif cardinalmulfix}
|
|
calcregisters(self,1,0,0);
|
|
{ for unsigned mul we need an extra register }
|
|
{ registers32:=left.registers32+right.registers32; }
|
|
if nodetype=muln then
|
|
inc(registers32);
|
|
convdone:=true;
|
|
end;
|
|
end
|
|
else
|
|
|
|
{ left side a setdef, must be before string processing,
|
|
else array constructor can be seen as array of char (PFV) }
|
|
if (ld^.deftype=setdef) {or is_array_constructor(ld)} then
|
|
begin
|
|
{ trying to add a set element? }
|
|
if (nodetype=addn) and (rd^.deftype<>setdef) then
|
|
begin
|
|
if (rt=setelementn) then
|
|
begin
|
|
if not(is_equal(psetdef(ld)^.elementtype.def,rd)) then
|
|
CGMessage(type_e_set_element_are_not_comp);
|
|
end
|
|
else
|
|
CGMessage(type_e_mismatch)
|
|
end
|
|
else
|
|
begin
|
|
if not(nodetype in [addn,subn,symdifn,muln,equaln,unequaln
|
|
{$IfNDef NoSetInclusion}
|
|
,lten,gten
|
|
{$EndIf NoSetInclusion}
|
|
]) then
|
|
CGMessage(type_e_set_operation_unknown);
|
|
{ right def must be a also be set }
|
|
if (rd^.deftype<>setdef) or not(is_equal(rd,ld)) then
|
|
CGMessage(type_e_set_element_are_not_comp);
|
|
end;
|
|
|
|
{ ranges require normsets }
|
|
if (psetdef(ld)^.settype=smallset) and
|
|
(rt=setelementn) and
|
|
assigned(tsetelementnode(right).right) then
|
|
begin
|
|
{ generate a temporary normset def, it'll be destroyed
|
|
when the symtable is unloaded }
|
|
tempdef:=new(psetdef,init(psetdef(ld)^.elementtype.def,255));
|
|
left:=gentypeconvnode(left,tempdef);
|
|
firstpass(left);
|
|
ld:=left.resulttype;
|
|
end;
|
|
|
|
{ if the destination is not a smallset then insert a typeconv
|
|
which loads a smallset into a normal set }
|
|
if (psetdef(ld)^.settype<>smallset) and
|
|
(psetdef(rd)^.settype=smallset) then
|
|
begin
|
|
if (right.nodetype=setconstn) then
|
|
begin
|
|
t:=gensetconstnode(tsetconstnode(right).value_set,psetdef(left.resulttype));
|
|
tsetconstnode(t).left:=tsetconstnode(right).left;
|
|
tsetconstnode(right).left:=nil;
|
|
right.free;
|
|
right:=t;
|
|
end
|
|
else
|
|
right:=gentypeconvnode(right,psetdef(left.resulttype));
|
|
firstpass(right);
|
|
end;
|
|
|
|
{ do constant evaluation }
|
|
if (right.nodetype=setconstn) and
|
|
not assigned(tsetconstnode(right).left) and
|
|
(left.nodetype=setconstn) and
|
|
not assigned(tsetconstnode(left).left) then
|
|
begin
|
|
new(resultset);
|
|
case nodetype of
|
|
addn : begin
|
|
for i:=0 to 31 do
|
|
resultset^[i]:=
|
|
tsetconstnode(right).value_set^[i] or tsetconstnode(left).value_set^[i];
|
|
t:=gensetconstnode(resultset,psetdef(ld));
|
|
end;
|
|
muln : begin
|
|
for i:=0 to 31 do
|
|
resultset^[i]:=
|
|
tsetconstnode(right).value_set^[i] and tsetconstnode(left).value_set^[i];
|
|
t:=gensetconstnode(resultset,psetdef(ld));
|
|
end;
|
|
subn : begin
|
|
for i:=0 to 31 do
|
|
resultset^[i]:=
|
|
tsetconstnode(left).value_set^[i] and not(tsetconstnode(right).value_set^[i]);
|
|
t:=gensetconstnode(resultset,psetdef(ld));
|
|
end;
|
|
symdifn : begin
|
|
for i:=0 to 31 do
|
|
resultset^[i]:=
|
|
tsetconstnode(left).value_set^[i] xor tsetconstnode(right).value_set^[i];
|
|
t:=gensetconstnode(resultset,psetdef(ld));
|
|
end;
|
|
unequaln : begin
|
|
b:=true;
|
|
for i:=0 to 31 do
|
|
if tsetconstnode(right).value_set^[i]=tsetconstnode(left).value_set^[i] then
|
|
begin
|
|
b:=false;
|
|
break;
|
|
end;
|
|
t:=genordinalconstnode(ord(b),booldef);
|
|
end;
|
|
equaln : begin
|
|
b:=true;
|
|
for i:=0 to 31 do
|
|
if tsetconstnode(right).value_set^[i]<>tsetconstnode(left).value_set^[i] then
|
|
begin
|
|
b:=false;
|
|
break;
|
|
end;
|
|
t:=genordinalconstnode(ord(b),booldef);
|
|
end;
|
|
{$IfNDef NoSetInclusion}
|
|
lten : Begin
|
|
b := true;
|
|
For i := 0 to 31 Do
|
|
If (tsetconstnode(right).value_set^[i] And tsetconstnode(left).value_set^[i]) <>
|
|
tsetconstnode(left).value_set^[i] Then
|
|
Begin
|
|
b := false;
|
|
Break
|
|
End;
|
|
t := genordinalconstnode(ord(b),booldef);
|
|
End;
|
|
gten : Begin
|
|
b := true;
|
|
For i := 0 to 31 Do
|
|
If (tsetconstnode(left).value_set^[i] And tsetconstnode(right).value_set^[i]) <>
|
|
tsetconstnode(right).value_set^[i] Then
|
|
Begin
|
|
b := false;
|
|
Break
|
|
End;
|
|
t := genordinalconstnode(ord(b),booldef);
|
|
End;
|
|
{$EndIf NoSetInclusion}
|
|
end;
|
|
dispose(resultset);
|
|
firstpass(t);
|
|
pass_1:=t;
|
|
exit;
|
|
end
|
|
else
|
|
if psetdef(ld)^.settype=smallset then
|
|
begin
|
|
{ are we adding set elements ? }
|
|
if right.nodetype=setelementn then
|
|
calcregisters(self,2,0,0)
|
|
else
|
|
calcregisters(self,1,0,0);
|
|
location.loc:=LOC_REGISTER;
|
|
end
|
|
else
|
|
begin
|
|
calcregisters(self,0,0,0);
|
|
{ here we call SET... }
|
|
procinfo^.flags:=procinfo^.flags or pi_do_call;
|
|
location.loc:=LOC_MEM;
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
{ compare pchar to char arrays by addresses
|
|
like BP/Delphi }
|
|
if (is_pchar(ld) and is_chararray(rd)) or
|
|
(is_pchar(rd) and is_chararray(ld)) then
|
|
begin
|
|
if is_chararray(rd) then
|
|
begin
|
|
right:=gentypeconvnode(right,ld);
|
|
firstpass(right);
|
|
end
|
|
else
|
|
begin
|
|
left:=gentypeconvnode(left,rd);
|
|
firstpass(left);
|
|
end;
|
|
location.loc:=LOC_REGISTER;
|
|
calcregisters(self,1,0,0);
|
|
convdone:=true;
|
|
end
|
|
else
|
|
{ is one of the operands a string?,
|
|
chararrays are also handled as strings (after conversion) }
|
|
if (rd^.deftype=stringdef) or (ld^.deftype=stringdef) or
|
|
((is_chararray(rd) or is_char(rd)) and
|
|
(is_chararray(ld) or is_char(ld))) then
|
|
begin
|
|
if is_widestring(rd) or is_widestring(ld) then
|
|
begin
|
|
if not(is_widestring(rd)) then
|
|
right:=gentypeconvnode(right,cwidestringdef);
|
|
if not(is_widestring(ld)) then
|
|
left:=gentypeconvnode(left,cwidestringdef);
|
|
resulttype:=cwidestringdef;
|
|
{ this is only for add, the comparisaion is handled later }
|
|
location.loc:=LOC_REGISTER;
|
|
end
|
|
else if is_ansistring(rd) or is_ansistring(ld) then
|
|
begin
|
|
if not(is_ansistring(rd)) then
|
|
right:=gentypeconvnode(right,cansistringdef);
|
|
if not(is_ansistring(ld)) then
|
|
left:=gentypeconvnode(left,cansistringdef);
|
|
{ we use ansistrings so no fast exit here }
|
|
procinfo^.no_fast_exit:=true;
|
|
resulttype:=cansistringdef;
|
|
{ this is only for add, the comparisaion is handled later }
|
|
location.loc:=LOC_REGISTER;
|
|
end
|
|
else if is_longstring(rd) or is_longstring(ld) then
|
|
begin
|
|
if not(is_longstring(rd)) then
|
|
right:=gentypeconvnode(right,clongstringdef);
|
|
if not(is_longstring(ld)) then
|
|
left:=gentypeconvnode(left,clongstringdef);
|
|
resulttype:=clongstringdef;
|
|
{ this is only for add, the comparisaion is handled later }
|
|
location.loc:=LOC_MEM;
|
|
end
|
|
else
|
|
begin
|
|
if not(is_shortstring(rd))
|
|
{$ifdef newoptimizations2}
|
|
{$ifdef i386}
|
|
{ shortstring + char handled seperately (JM) }
|
|
and (not(cs_optimize in aktglobalswitches) or
|
|
(nodetype <> addn) or not(is_char(rd)))
|
|
{$endif i386}
|
|
{$endif newoptimizations2}
|
|
then
|
|
right:=gentypeconvnode(right,cshortstringdef);
|
|
if not(is_shortstring(ld)) then
|
|
left:=gentypeconvnode(left,cshortstringdef);
|
|
resulttype:=cshortstringdef;
|
|
{ this is only for add, the comparisaion is handled later }
|
|
location.loc:=LOC_MEM;
|
|
end;
|
|
{ only if there is a type cast we need to do again }
|
|
{ the first pass }
|
|
if left.nodetype=typeconvn then
|
|
firstpass(left);
|
|
if right.nodetype=typeconvn then
|
|
firstpass(right);
|
|
{ here we call STRCONCAT or STRCMP or STRCOPY }
|
|
procinfo^.flags:=procinfo^.flags or pi_do_call;
|
|
if location.loc=LOC_MEM then
|
|
calcregisters(self,0,0,0)
|
|
else
|
|
calcregisters(self,1,0,0);
|
|
{$ifdef newoptimizations2}
|
|
{$ifdef i386}
|
|
{ not always necessary, only if it is not a constant char and }
|
|
{ not a regvar, but don't know how to check this here (JM) }
|
|
if is_char(rd) then
|
|
inc(registers32);
|
|
{$endif i386}
|
|
{$endif newoptimizations2}
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
{ is one a real float ? }
|
|
if (rd^.deftype=floatdef) or (ld^.deftype=floatdef) then
|
|
begin
|
|
{ if one is a fixed, then convert to f32bit }
|
|
if ((rd^.deftype=floatdef) and (pfloatdef(rd)^.typ=f32bit)) or
|
|
((ld^.deftype=floatdef) and (pfloatdef(ld)^.typ=f32bit)) then
|
|
begin
|
|
if not is_integer(rd) or (nodetype<>muln) then
|
|
right:=gentypeconvnode(right,s32fixeddef);
|
|
if not is_integer(ld) or (nodetype<>muln) then
|
|
left:=gentypeconvnode(left,s32fixeddef);
|
|
firstpass(left);
|
|
firstpass(right);
|
|
calcregisters(self,1,0,0);
|
|
location.loc:=LOC_REGISTER;
|
|
end
|
|
else
|
|
{ convert both to bestreal }
|
|
begin
|
|
right:=gentypeconvnode(right,bestrealdef^);
|
|
left:=gentypeconvnode(left,bestrealdef^);
|
|
firstpass(left);
|
|
firstpass(right);
|
|
calcregisters(self,0,1,0);
|
|
location.loc:=LOC_FPU;
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
{ pointer comperation and subtraction }
|
|
if (rd^.deftype=pointerdef) and (ld^.deftype=pointerdef) then
|
|
begin
|
|
location.loc:=LOC_REGISTER;
|
|
{ right:=gentypeconvnode(right,ld); }
|
|
{ firstpass(right); }
|
|
calcregisters(self,1,0,0);
|
|
case nodetype of
|
|
equaln,unequaln :
|
|
begin
|
|
if is_equal(right.resulttype,voidpointerdef) then
|
|
begin
|
|
right:=gentypeconvnode(right,ld);
|
|
firstpass(right);
|
|
end
|
|
else if is_equal(left.resulttype,voidpointerdef) then
|
|
begin
|
|
left:=gentypeconvnode(left,rd);
|
|
firstpass(left);
|
|
end
|
|
else if not(is_equal(ld,rd)) then
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
ltn,lten,gtn,gten:
|
|
begin
|
|
if is_equal(right.resulttype,voidpointerdef) then
|
|
begin
|
|
right:=gentypeconvnode(right,ld);
|
|
firstpass(right);
|
|
end
|
|
else if is_equal(left.resulttype,voidpointerdef) then
|
|
begin
|
|
left:=gentypeconvnode(left,rd);
|
|
firstpass(left);
|
|
end
|
|
else if not(is_equal(ld,rd)) then
|
|
CGMessage(type_e_mismatch);
|
|
if not(cs_extsyntax in aktmoduleswitches) then
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
subn:
|
|
begin
|
|
if not(is_equal(ld,rd)) then
|
|
CGMessage(type_e_mismatch);
|
|
if not(cs_extsyntax in aktmoduleswitches) then
|
|
CGMessage(type_e_mismatch);
|
|
resulttype:=s32bitdef;
|
|
exit;
|
|
end;
|
|
else CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
if (rd^.deftype=objectdef) and (ld^.deftype=objectdef) and
|
|
pobjectdef(rd)^.is_class and pobjectdef(ld)^.is_class then
|
|
begin
|
|
location.loc:=LOC_REGISTER;
|
|
if pobjectdef(rd)^.is_related(pobjectdef(ld)) then
|
|
right:=gentypeconvnode(right,ld)
|
|
else
|
|
left:=gentypeconvnode(left,rd);
|
|
firstpass(right);
|
|
firstpass(left);
|
|
calcregisters(self,1,0,0);
|
|
case nodetype of
|
|
equaln,unequaln : ;
|
|
else CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
if (rd^.deftype=classrefdef) and (ld^.deftype=classrefdef) then
|
|
begin
|
|
location.loc:=LOC_REGISTER;
|
|
if pobjectdef(pclassrefdef(rd)^.pointertype.def)^.is_related(pobjectdef(
|
|
pclassrefdef(ld)^.pointertype.def)) then
|
|
right:=gentypeconvnode(right,ld)
|
|
else
|
|
left:=gentypeconvnode(left,rd);
|
|
firstpass(right);
|
|
firstpass(left);
|
|
calcregisters(self,1,0,0);
|
|
case nodetype of
|
|
equaln,unequaln : ;
|
|
else CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
{ allows comperasion with nil pointer }
|
|
if (rd^.deftype=objectdef) and
|
|
pobjectdef(rd)^.is_class then
|
|
begin
|
|
location.loc:=LOC_REGISTER;
|
|
left:=gentypeconvnode(left,rd);
|
|
firstpass(left);
|
|
calcregisters(self,1,0,0);
|
|
case nodetype of
|
|
equaln,unequaln : ;
|
|
else CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
if (ld^.deftype=objectdef) and
|
|
pobjectdef(ld)^.is_class then
|
|
begin
|
|
location.loc:=LOC_REGISTER;
|
|
right:=gentypeconvnode(right,ld);
|
|
firstpass(right);
|
|
calcregisters(self,1,0,0);
|
|
case nodetype of
|
|
equaln,unequaln : ;
|
|
else CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
if (rd^.deftype=classrefdef) then
|
|
begin
|
|
left:=gentypeconvnode(left,rd);
|
|
firstpass(left);
|
|
calcregisters(self,1,0,0);
|
|
case nodetype of
|
|
equaln,unequaln : ;
|
|
else CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
if (ld^.deftype=classrefdef) then
|
|
begin
|
|
right:=gentypeconvnode(right,ld);
|
|
firstpass(right);
|
|
calcregisters(self,1,0,0);
|
|
case nodetype of
|
|
equaln,unequaln : ;
|
|
else
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
{ support procvar=nil,procvar<>nil }
|
|
if ((ld^.deftype=procvardef) and (rt=niln)) or
|
|
((rd^.deftype=procvardef) and (lt=niln)) then
|
|
begin
|
|
calcregisters(self,1,0,0);
|
|
location.loc:=LOC_REGISTER;
|
|
case nodetype of
|
|
equaln,unequaln : ;
|
|
else
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
{$ifdef SUPPORT_MMX}
|
|
if (cs_mmx in aktlocalswitches) and is_mmx_able_array(ld) and
|
|
is_mmx_able_array(rd) and is_equal(ld,rd) then
|
|
begin
|
|
firstpass(right);
|
|
firstpass(left);
|
|
case nodetype of
|
|
addn,subn,xorn,orn,andn:
|
|
;
|
|
{ mul is a little bit restricted }
|
|
muln:
|
|
if not(mmx_type(left.resulttype) in
|
|
[mmxu16bit,mmxs16bit,mmxfixed16]) then
|
|
CGMessage(type_e_mismatch);
|
|
else
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
location.loc:=LOC_MMXREGISTER;
|
|
calcregisters(self,0,0,1);
|
|
convdone:=true;
|
|
end
|
|
else
|
|
{$endif SUPPORT_MMX}
|
|
|
|
{ this is a little bit dangerous, also the left type }
|
|
{ should be checked! This broke the mmx support }
|
|
if (rd^.deftype=pointerdef) or
|
|
is_zero_based_array(rd) then
|
|
begin
|
|
if is_zero_based_array(rd) then
|
|
begin
|
|
resulttype:=new(ppointerdef,init(parraydef(rd)^.elementtype));
|
|
right:=gentypeconvnode(right,resulttype);
|
|
firstpass(right);
|
|
end;
|
|
location.loc:=LOC_REGISTER;
|
|
left:=gentypeconvnode(left,s32bitdef);
|
|
firstpass(left);
|
|
calcregisters(self,1,0,0);
|
|
if nodetype=addn then
|
|
begin
|
|
if not(cs_extsyntax in aktmoduleswitches) or
|
|
(not(is_pchar(ld)) and not(m_add_pointer in aktmodeswitches)) then
|
|
CGMessage(type_e_mismatch);
|
|
{ Dirty hack, to support multiple firstpasses (PFV) }
|
|
if (resulttype=nil) and
|
|
(rd^.deftype=pointerdef) and
|
|
(ppointerdef(rd)^.pointertype.def^.size>1) then
|
|
begin
|
|
left:=caddnode.create(muln,left,genordinalconstnode(ppointerdef(rd)^.pointertype.def^.size,s32bitdef));
|
|
firstpass(left);
|
|
end;
|
|
end
|
|
else
|
|
CGMessage(type_e_mismatch);
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
if (ld^.deftype=pointerdef) or
|
|
is_zero_based_array(ld) then
|
|
begin
|
|
if is_zero_based_array(ld) then
|
|
begin
|
|
resulttype:=new(ppointerdef,init(parraydef(ld)^.elementtype));
|
|
left:=gentypeconvnode(left,resulttype);
|
|
firstpass(left);
|
|
end;
|
|
location.loc:=LOC_REGISTER;
|
|
right:=gentypeconvnode(right,s32bitdef);
|
|
firstpass(right);
|
|
calcregisters(self,1,0,0);
|
|
case nodetype of
|
|
addn,subn : begin
|
|
if not(cs_extsyntax in aktmoduleswitches) or
|
|
(not(is_pchar(ld)) and not(m_add_pointer in aktmodeswitches)) then
|
|
CGMessage(type_e_mismatch);
|
|
{ Dirty hack, to support multiple firstpasses (PFV) }
|
|
if (resulttype=nil) and
|
|
(ld^.deftype=pointerdef) and
|
|
(ppointerdef(ld)^.pointertype.def^.size>1) then
|
|
begin
|
|
right:=caddnode.create(muln,right,
|
|
genordinalconstnode(ppointerdef(ld)^.pointertype.def^.size,s32bitdef));
|
|
firstpass(right);
|
|
end;
|
|
end;
|
|
else
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
if (rd^.deftype=procvardef) and (ld^.deftype=procvardef) and is_equal(rd,ld) then
|
|
begin
|
|
calcregisters(self,1,0,0);
|
|
location.loc:=LOC_REGISTER;
|
|
case nodetype of
|
|
equaln,unequaln : ;
|
|
else
|
|
CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end
|
|
else
|
|
|
|
if (ld^.deftype=enumdef) and (rd^.deftype=enumdef) then
|
|
begin
|
|
if not(is_equal(ld,rd)) then
|
|
begin
|
|
right:=gentypeconvnode(right,ld);
|
|
firstpass(right);
|
|
end;
|
|
calcregisters(self,1,0,0);
|
|
case nodetype of
|
|
equaln,unequaln,
|
|
ltn,lten,gtn,gten : ;
|
|
else CGMessage(type_e_mismatch);
|
|
end;
|
|
convdone:=true;
|
|
end;
|
|
|
|
{ the general solution is to convert to 32 bit int }
|
|
if not convdone then
|
|
begin
|
|
{ but an int/int gives real/real! }
|
|
if nodetype=slashn then
|
|
begin
|
|
CGMessage(type_h_use_div_for_int);
|
|
right:=gentypeconvnode(right,bestrealdef^);
|
|
left:=gentypeconvnode(left,bestrealdef^);
|
|
firstpass(left);
|
|
firstpass(right);
|
|
{ maybe we need an integer register to save }
|
|
{ a reference }
|
|
if ((left.location.loc<>LOC_FPU) or
|
|
(right.location.loc<>LOC_FPU)) and
|
|
(left.registers32=right.registers32) then
|
|
calcregisters(self,1,1,0)
|
|
else
|
|
calcregisters(self,0,1,0);
|
|
location.loc:=LOC_FPU;
|
|
end
|
|
else
|
|
begin
|
|
right:=gentypeconvnode(right,s32bitdef);
|
|
left:=gentypeconvnode(left,s32bitdef);
|
|
firstpass(left);
|
|
firstpass(right);
|
|
calcregisters(self,1,0,0);
|
|
location.loc:=LOC_REGISTER;
|
|
end;
|
|
end;
|
|
|
|
if codegenerror then
|
|
exit;
|
|
|
|
{ determines result type for comparions }
|
|
{ here the is a problem with multiple passes }
|
|
{ example length(s)+1 gets internal 'longint' type first }
|
|
{ if it is a arg it is converted to 'LONGINT' }
|
|
{ but a second first pass will reset this to 'longint' }
|
|
case nodetype of
|
|
ltn,lten,gtn,gten,equaln,unequaln:
|
|
begin
|
|
if (not assigned(resulttype)) or
|
|
(resulttype^.deftype=stringdef) then
|
|
resulttype:=booldef;
|
|
if is_64bitint(left.resulttype) then
|
|
location.loc:=LOC_JUMP
|
|
else
|
|
location.loc:=LOC_FLAGS;
|
|
end;
|
|
xorn:
|
|
begin
|
|
if not assigned(resulttype) then
|
|
resulttype:=left.resulttype;
|
|
location.loc:=LOC_REGISTER;
|
|
end;
|
|
addn:
|
|
begin
|
|
if not assigned(resulttype) then
|
|
begin
|
|
{ for strings, return is always a 255 char string }
|
|
if is_shortstring(left.resulttype) then
|
|
resulttype:=cshortstringdef
|
|
else
|
|
resulttype:=left.resulttype;
|
|
end;
|
|
end;
|
|
{$ifdef cardinalmulfix}
|
|
muln:
|
|
{ if we multiply an unsigned with a signed number, the result is signed }
|
|
{ in the other cases, the result remains signed or unsigned depending on }
|
|
{ the multiplication factors (JM) }
|
|
if (left.resulttype^.deftype = orddef) and
|
|
(right.resulttype^.deftype = orddef) and
|
|
is_signed(right.resulttype) then
|
|
resulttype := right.resulttype
|
|
else resulttype := left.resulttype;
|
|
(*
|
|
subn:
|
|
{ if we substract a u32bit from a positive constant, the result becomes }
|
|
{ s32bit as well (JM) }
|
|
begin
|
|
if (right.resulttype^.deftype = orddef) and
|
|
(left.resulttype^.deftype = orddef) and
|
|
(porddef(right.resulttype)^.typ = u32bit) and
|
|
is_constintnode(left) and
|
|
{ (porddef(left.resulttype)^.typ <> u32bit) and}
|
|
(left.value > 0) then
|
|
begin
|
|
left := gentypeconvnode(left,u32bitdef);
|
|
firstpass(left);
|
|
end;
|
|
resulttype:=left.resulttype;
|
|
end;
|
|
*)
|
|
{$endif cardinalmulfix}
|
|
else
|
|
resulttype:=left.resulttype;
|
|
end;
|
|
end;
|
|
|
|
begin
|
|
caddnode:=taddnode;
|
|
end.
|
|
{
|
|
$Log$
|
|
Revision 1.12 2000-10-01 19:48:23 peter
|
|
* lot of compile updates for cg11
|
|
|
|
Revision 1.11 2000/09/30 16:08:45 peter
|
|
* more cg11 updates
|
|
|
|
Revision 1.10 2000/09/28 19:49:52 florian
|
|
*** empty log message ***
|
|
|
|
Revision 1.9 2000/09/27 21:33:22 florian
|
|
* finally nadd.pas compiles
|
|
|
|
Revision 1.8 2000/09/27 20:25:44 florian
|
|
* more stuff fixed
|
|
|
|
Revision 1.7 2000/09/27 18:14:31 florian
|
|
* fixed a lot of syntax errors in the n*.pas stuff
|
|
|
|
Revision 1.6 2000/09/24 15:06:19 peter
|
|
* use defines.inc
|
|
|
|
Revision 1.5 2000/09/22 22:42:52 florian
|
|
* more fixes
|
|
|
|
Revision 1.4 2000/09/21 12:22:42 jonas
|
|
* put piece of code between -dnewoptimizations2 since it wasn't
|
|
necessary otherwise
|
|
+ support for full boolean evaluation (from tcadd)
|
|
|
|
Revision 1.3 2000/09/20 21:50:59 florian
|
|
* updated
|
|
|
|
Revision 1.2 2000/08/29 08:24:45 jonas
|
|
* some modifications to -dcardinalmulfix code
|
|
|
|
Revision 1.1 2000/08/26 12:24:20 florian
|
|
* initial release
|
|
} |