//main
int main()
{
printf("\nWelcome!! This program performs the addition of three integers 2,4,6 \nand division of three numbers 36.0,3.0,2.0\n");
//Addition
addValues(2,4,6);
//Division
callfunc(36.0,3.0,2.0);
printf("\nThank you..\n\n");
return 0;
}
int
main (void)
{
return callfunc (func);
}
void ForeachStatement::toIR(IRState *irs)
{
printf("ForeachStatement::toIR() %s\n", toChars());
assert(0); // done by "lowering" in the front end
#if 0
Type *tab;
elem *eaggr;
elem *e;
elem *elength;
tym_t keytym;
//printf("ForeachStatement::toIR()\n");
block *bpre;
block *bcond;
block *bbody;
block *bbodyx;
Blockx *blx = irs->blx;
IRState mystate(irs,this);
mystate.breakBlock = block_calloc(blx);
mystate.contBlock = block_calloc(blx);
tab = aggr->type->toBasetype();
assert(tab->ty == Tarray || tab->ty == Tsarray);
incUsage(irs, aggr->loc);
eaggr = aggr->toElem(irs);
/* Create sp: pointer to start of array data
*/
Symbol *sp = symbol_genauto(TYnptr);
if (tab->ty == Tarray)
{
// stmp is copy of eaggr (the array), so eaggr is evaluated only once
Symbol *stmp;
// Initialize stmp
stmp = symbol_genauto(eaggr);
e = el_bin(OPeq, eaggr->Ety, el_var(stmp), eaggr);
block_appendexp(blx->curblock, e);
// Initialize sp
e = el_una(OPmsw, TYnptr, el_var(stmp));
e = el_bin(OPeq, TYnptr, el_var(sp), e);
block_appendexp(blx->curblock, e);
// Get array.length
elength = el_var(stmp);
elength->Ety = TYsize_t;
}
else // Tsarray
{
// Initialize sp
e = el_una(OPaddr, TYnptr, eaggr);
e = el_bin(OPeq, TYnptr, el_var(sp), e);
block_appendexp(blx->curblock, e);
// Get array.length
elength = el_long(TYsize_t, ((TypeSArray *)tab)->dim->toInteger());
}
Symbol *spmax;
Symbol *skey;
if (key)
{
/* Create skey, the index to the array.
* Initialize skey to 0 (foreach) or .length (foreach_reverse).
*/
skey = key->toSymbol();
symbol_add(skey);
keytym = key->type->totym();
elem *einit = (op == TOKforeach_reverse) ? elength : el_long(keytym, 0);
e = el_bin(OPeq, keytym, el_var(skey), einit);
}
else
{
/* Create spmax, pointer past end of data.
* Initialize spmax = sp + array.length * size
*/
spmax = symbol_genauto(TYnptr);
e = el_bin(OPmul, TYsize_t, elength, el_long(TYsize_t, tab->nextOf()->size()));
e = el_bin(OPadd, TYnptr, el_var(sp), e);
e = el_bin(OPeq, TYnptr, el_var(spmax), e);
/* For foreach_reverse, swap sp and spmax
*/
if (op == TOKforeach_reverse)
{ Symbol *s = sp;
sp = spmax;
spmax = s;
}
}
block_appendexp(blx->curblock, e);
bpre = blx->curblock;
block_next(blx,BCgoto,NULL);
bcond = blx->curblock;
if (key)
{
if (op == TOKforeach_reverse)
{
// Construct (key != 0)
e = el_bin(OPne, TYint, el_var(skey), el_long(keytym, 0));
}
else
{
// Construct (key < elength)
e = el_bin(OPlt, TYint, el_var(skey), elength);
}
}
else
{
if (op == TOKforeach_reverse)
{
// Construct (sp > spmax)
e = el_bin(OPgt, TYint, el_var(sp), el_var(spmax));
}
else
{
// Construct (sp < spmax)
e = el_bin(OPlt, TYint, el_var(sp), el_var(spmax));
}
}
bcond->Belem = e;
block_next(blx, BCiftrue, NULL);
if (op == TOKforeach_reverse)
{
if (key)
{ // Construct (skey -= 1)
e = el_bin(OPminass, keytym, el_var(skey), el_long(keytym, 1));
}
else
{ // Construct (sp--)
e = el_bin(OPminass, TYnptr, el_var(sp), el_long(TYsize_t, tab->nextOf()->size()));
}
block_appendexp(blx->curblock, e);
}
Symbol *s;
FuncDeclaration *fd = NULL;
if (value->toParent2())
fd = value->toParent2()->isFuncDeclaration();
int nrvo = 0;
if (fd && fd->nrvo_can && fd->nrvo_var == value)
{
s = fd->shidden;
nrvo = 1;
}
else
{ s = value->toSymbol();
symbol_add(s);
}
// Construct (value = *sp) or (value = sp[skey * elemsize])
tym_t tym = value->type->totym();
if (key)
{ // sp + skey * elemsize
e = el_bin(OPmul, keytym, el_var(skey), el_long(keytym, tab->nextOf()->size()));
e = el_bin(OPadd, TYnptr, el_var(sp), e);
}
else
e = el_var(sp);
elem *evalue;
#if DMDV2
if (value->offset) // if value is a member of a closure
{
assert(irs->sclosure);
evalue = el_var(irs->sclosure);
evalue = el_bin(OPadd, TYnptr, evalue, el_long(TYint, value->offset));
evalue = el_una(OPind, value->type->totym(), evalue);
}
else
#endif
evalue = el_var(s);
if (value->isOut() || value->isRef())
{
assert(value->storage_class & (STCout | STCref));
e = el_bin(OPeq, TYnptr, evalue, e);
}
else
{
if (nrvo)
evalue = el_una(OPind, tym, evalue);
StructDeclaration *sd = needsPostblit(value->type);
if (tybasic(tym) == TYstruct)
{
e = el_bin(OPeq, tym, evalue, el_una(OPind, tym, e));
e->Eoper = OPstreq;
e->ET = value->type->toCtype();
#if DMDV2
// Call postblit on e
if (sd)
{ FuncDeclaration *fd = sd->postblit;
elem *ec = el_copytree(evalue);
ec = el_una(OPaddr, TYnptr, ec);
ec = callfunc(loc, irs, 1, Type::tvoid, ec, sd->type->pointerTo(), fd, fd->type, NULL, NULL);
e = el_combine(e, ec);
}
#endif
}
else if (tybasic(tym) == TYarray)
{
if (sd)
{
/* Generate:
* _d_arrayctor(ti, efrom, eto)
*/
Expression *ti = value->type->toBasetype()->nextOf()->toBasetype()->getTypeInfo(NULL);
elem *esize = el_long(TYsize_t, ((TypeSArray *)value->type->toBasetype())->dim->toInteger());
elem *eto = el_pair(TYdarray, esize, el_una(OPaddr, TYnptr, evalue));
elem *efrom = el_pair(TYdarray, el_copytree(esize), e);
elem *ep = el_params(eto, efrom, ti->toElem(irs), NULL);
int rtl = RTLSYM_ARRAYCTOR;
e = el_bin(OPcall, TYvoid, el_var(rtlsym[rtl]), ep);
}
else
{
e = el_bin(OPeq, tym, evalue, el_una(OPind, tym, e));
e->Eoper = OPstreq;
e->Ejty = e->Ety = TYstruct;
e->ET = value->type->toCtype();
}
}
else
e = el_bin(OPeq, tym, evalue, el_una(OPind, tym, e));
}
incUsage(irs, loc);
block_appendexp(blx->curblock, e);
bbody = blx->curblock;
if (body)
body->toIR(&mystate);
bbodyx = blx->curblock;
block_next(blx,BCgoto,mystate.contBlock);
if (op == TOKforeach)
{
if (key)
{ // Construct (skey += 1)
e = el_bin(OPaddass, keytym, el_var(skey), el_long(keytym, 1));
}
else
{ // Construct (sp++)
e = el_bin(OPaddass, TYnptr, el_var(sp), el_long(TYsize_t, tab->nextOf()->size()));
}
mystate.contBlock->Belem = e;
}
block_next(blx,BCgoto,mystate.breakBlock);
list_append(&bpre->Bsucc,bcond);
list_append(&bcond->Bsucc,bbody);
list_append(&bcond->Bsucc,mystate.breakBlock);
list_append(&bbodyx->Bsucc,mystate.contBlock);
list_append(&mystate.contBlock->Bsucc,bcond);
#endif
}
void ReturnStatement::toIR(IRState *irs)
{
Blockx *blx = irs->blx;
incUsage(irs, loc);
if (exp)
{ elem *e;
FuncDeclaration *func = irs->getFunc();
assert(func);
assert(func->type->ty == Tfunction);
TypeFunction *tf = (TypeFunction *)(func->type);
enum RET retmethod = tf->retStyle();
if (retmethod == RETstack)
{
elem *es;
/* If returning struct literal, write result
* directly into return value
*/
if (exp->op == TOKstructliteral)
{ StructLiteralExp *se = (StructLiteralExp *)exp;
char save[sizeof(StructLiteralExp)];
memcpy(save, se, sizeof(StructLiteralExp));
se->sym = irs->shidden;
se->soffset = 0;
se->fillHoles = 1;
e = exp->toElemDtor(irs);
memcpy(se, save, sizeof(StructLiteralExp));
}
else
e = exp->toElemDtor(irs);
assert(e);
if (exp->op == TOKstructliteral ||
(func->nrvo_can && func->nrvo_var))
{
// Return value via hidden pointer passed as parameter
// Write exp; return shidden;
es = e;
}
else
{
// Return value via hidden pointer passed as parameter
// Write *shidden=exp; return shidden;
int op;
tym_t ety;
ety = e->Ety;
es = el_una(OPind,ety,el_var(irs->shidden));
op = (tybasic(ety) == TYstruct) ? OPstreq : OPeq;
es = el_bin(op, ety, es, e);
if (op == OPstreq)
es->ET = exp->type->toCtype();
#if DMDV2
/* Call postBlit() on *shidden
*/
Type *tb = exp->type->toBasetype();
//if (tb->ty == Tstruct) exp->dump(0);
if ((exp->op == TOKvar || exp->op == TOKdotvar || exp->op == TOKstar || exp->op == TOKthis) &&
tb->ty == Tstruct)
{ StructDeclaration *sd = ((TypeStruct *)tb)->sym;
if (sd->postblit)
{ FuncDeclaration *fd = sd->postblit;
if (fd->storage_class & STCdisable)
{
fd->toParent()->error(loc, "is not copyable because it is annotated with @disable");
}
elem *ec = el_var(irs->shidden);
ec = callfunc(loc, irs, 1, Type::tvoid, ec, tb->pointerTo(), fd, fd->type, NULL, NULL);
es = el_bin(OPcomma, ec->Ety, es, ec);
}
#if 0
/* It has been moved, so disable destructor
*/
if (exp->op == TOKvar)
{ VarExp *ve = (VarExp *)exp;
VarDeclaration *v = ve->var->isVarDeclaration();
if (v && v->rundtor)
{
elem *er = el_var(v->rundtor->toSymbol());
er = el_bin(OPeq, TYint, er, el_long(TYint, 0));
es = el_bin(OPcomma, TYint, es, er);
}
}
#endif
}
#endif
}
e = el_var(irs->shidden);
e = el_bin(OPcomma, e->Ety, es, e);
}
#if DMDV2
else if (tf->isref)
{ // Reference return, so convert to a pointer
Expression *ae = exp->addressOf(NULL);
e = ae->toElemDtor(irs);
}
#endif
else
{
e = exp->toElemDtor(irs);
assert(e);
}
elem_setLoc(e, loc);
block_appendexp(blx->curblock, e);
block_next(blx, BCretexp, NULL);
}
else
block_next(blx, BCret, NULL);
}
void ReturnStatement::toIR(IRState *irs)
{
Blockx *blx = irs->blx;
enum BC bc;
incUsage(irs, loc);
if (exp)
{ elem *e;
FuncDeclaration *func = irs->getFunc();
assert(func);
assert(func->type->ty == Tfunction);
TypeFunction *tf = (TypeFunction *)(func->type);
enum RET retmethod = tf->retStyle();
if (retmethod == RETstack)
{
elem *es;
/* If returning struct literal, write result
* directly into return value
*/
if (exp->op == TOKstructliteral)
{ StructLiteralExp *se = (StructLiteralExp *)exp;
char save[sizeof(StructLiteralExp)];
memcpy(save, se, sizeof(StructLiteralExp));
se->sym = irs->shidden;
se->soffset = 0;
se->fillHoles = 1;
e = exp->toElemDtor(irs);
memcpy(se, save, sizeof(StructLiteralExp));
}
else
e = exp->toElemDtor(irs);
assert(e);
if (exp->op == TOKstructliteral ||
(func->nrvo_can && func->nrvo_var))
{
// Return value via hidden pointer passed as parameter
// Write exp; return shidden;
es = e;
}
else
{
// Return value via hidden pointer passed as parameter
// Write *shidden=exp; return shidden;
int op;
tym_t ety;
ety = e->Ety;
es = el_una(OPind,ety,el_var(irs->shidden));
op = (tybasic(ety) == TYstruct) ? OPstreq : OPeq;
es = el_bin(op, ety, es, e);
if (op == OPstreq)
es->ET = exp->type->toCtype();
#if 0//DMDV2
/* Call postBlit() on *shidden
*/
Type *tb = exp->type->toBasetype();
//if (tb->ty == Tstruct) exp->dump(0);
if (exp->isLvalue() && tb->ty == Tstruct)
{ StructDeclaration *sd = ((TypeStruct *)tb)->sym;
if (sd->postblit)
{ FuncDeclaration *fd = sd->postblit;
if (fd->storage_class & STCdisable)
{
fd->toParent()->error(loc, "is not copyable because it is annotated with @disable");
}
elem *ec = el_var(irs->shidden);
ec = callfunc(loc, irs, 1, Type::tvoid, ec, tb->pointerTo(), fd, fd->type, NULL, NULL);
es = el_bin(OPcomma, ec->Ety, es, ec);
}
}
#endif
}
e = el_var(irs->shidden);
e = el_bin(OPcomma, e->Ety, es, e);
}
#if DMDV2
else if (tf->isref)
{ // Reference return, so convert to a pointer
Expression *ae = exp->addressOf(NULL);
e = ae->toElemDtor(irs);
}
#endif
else
{
e = exp->toElemDtor(irs);
assert(e);
}
elem_setLoc(e, loc);
block_appendexp(blx->curblock, e);
bc = BCretexp;
}
else
bc = BCret;
block *btry = blx->curblock->Btry;
if (btry)
{
// A finally block is a successor to a return block inside a try-finally
if (btry->numSucc() == 2) // try-finally
{
block *bfinally = btry->nthSucc(1);
assert(bfinally->BC == BC_finally);
blx->curblock->appendSucc(bfinally);
}
}
block_next(blx, bc, NULL);
}
