expr.c

CC386 is a general-purpose 32-bit C compiler. It is not an optimizing compiler but given that the co

            {
                ENODE *pnode = makenode(en_napccon, sp, 0);
                ENODE *qn,  *rnode,  *tcnode = makenode(en_substack,
                    makeintnode(en_icon, sp_in->tp->size), 0);
                sp->mainsym->extflag = TRUE;
                qn = makenode(en_void, en, 0);
                qn = makenode(en_void, qn, 0);
                rnode = makenode(en_void, pnode, pnode);
                pnode = makenode(en_void, rnode, qn);
                rnode = makeintnode(en_icon, sp->tp->btp->size);
                if (sp->pascaldefn)
                    pnode = makenode(en_pfcall, rnode, pnode);
                else
                    if (sp->isstdcall)
                        pnode = makenode(en_sfcall, rnode, pnode);
                    else
                        pnode = makenode(en_fcall, rnode, pnode);
                pnode = makenode(en_thiscall, tcnode, pnode);
                pnode = doinline(pnode);
                epx = makenode(en_void, pnode, ep1);
            }
        }
    }
    if (!epx)
    {
        checkstructconst(sp_in->tp);
        epx = makenode(en_stackblock, en, ep1);
        en->size = sp_in->tp->size;
    }
    return epx;
}

//-------------------------------------------------------------------------

ENODE *cbll(ENODE *ep1, ENODE *ep2, TYP *tp)
{
    if (ep2->nodetype == en_pfcallb)
        ep1 = makenode(en_pcallblock, ep1, ep2);
    else
        if (ep2->nodetype == en_sfcallb)
            ep1 = makenode(en_scallblock, ep1, ep2);
        else
            ep1 = makenode(en_callblock, ep1, ep2);

    return ep1;
}

//-------------------------------------------------------------------------

ENODE *make_callblock(ENODE *ep1, ENODE *ep2, TYP *tp, int size)
{
        ENODE *ep3,  *ep4;
        ENODE *rnode;
        int thiscall = 0;
        if (ep2->nodetype == en_thiscall)
        {
            ep3 = ep2->v.p[0];
            ep2 = ep2->v.p[1];
            thiscall = 1;
        }
    if (ep2->nodetype == en_fcallb || ep2->nodetype == en_pfcallb || ep2
        ->nodetype == en_sfcallb)
    {
        if (!ep1)
            ep1 = (ENODE*)dummyvar(size, tp, 0);

        ep4 = ep1 = cbll(ep1, ep2, tp);
        if (thiscall)
            ep1 = makenode(en_thiscall, ep3, ep1);
        if (prm_cplusplus)
        {
            TYP tp3;
            ep1 = makenode(en_conslabel, ep1, (void*)copynode(ep4->v.p[0]));
            tp3.lst.head =  - 1;
            tp3.lst.tail =  - 1;
            tp3.type = bt_func;
            rnode = do_destructor(ep4->v.p[0]->v.sp, &tp3, tp, 0, 1, 0, TRUE);
            if (!rnode)
                rnode = makenode(en_destlabel, makeintnode(en_icon, 0), (void*)
                    copynode(ep4->v.p[0]));
            if (block_rundown)
                block_rundown = makenode(en_void, rnode, block_rundown);
            else
                block_rundown = rnode;
        }
    }
        else
        {
            if (thiscall || !ep1)
                ep1 = ep2;
            ep4 = ep1;
            if (thiscall)
                ep1 = makenode(en_thiscall, ep3, ep1);
            if (prm_cplusplus)
                ep1 = makenode(en_conslabel, ep1, (void*)copynode(ep4->v.p[0]));
            rnode = makenode(en_destlabel, makeintnode(en_icon, 0), (void*)
                copynode(ep4->v.p[0]));
            if (block_rundown)
                block_rundown = makenode(en_void, rnode, block_rundown);
            else
                block_rundown = rnode;
        }
    return ep1;
}

//-------------------------------------------------------------------------

ENODE *immed_callblock(ENODE *ep1, ENODE *ep2, TYP *tp, int size)
{
    ENODE *obd = block_rundown,  *rv;
    block_rundown = 0;
    rv = make_callblock(ep1, ep2, tp, size);
    rv = makenode(en_void, rv, block_rundown);
    block_rundown = obd;
    return rv;
}

//-------------------------------------------------------------------------

ENODE *repcallb(ENODE *ep2)
/*
 * repcallb replaces callblocks that haven't been resolved to a return address
 *	by allocating a return struct
 */
{
    if (ep2 == 0)
        return ep2;
    switch (ep2->nodetype)
    {
        case en_structret:
        case en_placeholder:
        case en_regref:
            break;
        case en_conslabel:
        case en_destlabel:
        case en_movebyref:
            ep2->v.p[0] = repcallb(ep2->v.p[0]);
            break;
        case en_rcomplexcon:
        case en_lrcomplexcon:
        case en_fcomplexcon:
        case en_rimaginarycon:
        case en_lrimaginarycon:
        case en_fimaginarycon:
        case en_rcon:
        case en_lrcon:
        case en_fcon:
        case en_icon:
        case en_lcon:
        case en_iucon:
        case en_lucon:
        case en_llcon:
        case en_llucon:
        case en_boolcon:
        case en_ccon:
        case en_cucon:
        case en_nacon:
        case en_napccon:
        case en_absacon:
        case en_autocon:
        case en_autoreg:
        case en_labcon:
        case en_nalabcon:
            break;
        case en_fp_ref:
            ep2->v.p[0] = repcallb(ep2->v.p[0]);
            break;
        case en_fcomplexref:
        case en_rcomplexref:
        case en_lrcomplexref:
            ep2->v.p[0] = repcallb(ep2->v.p[0]);
            break;
        case en_floatref:
        case en_doubleref:
        case en_longdoubleref:
        case en_fimaginaryref:
        case en_rimaginaryref:
        case en_lrimaginaryref:
        case en_ub_ref:
        case en_uw_ref:
        case en_b_ref:
        case en_bool_ref:
        case en_w_ref:
        case en_l_ref:
        case en_ul_ref:
		case en_i_ref:
		case en_ui_ref:
		case en_a_ref: case en_ua_ref:
            ep2->v.p[0] = repcallb(ep2->v.p[0]);
            break;
        case en_ll_ref:
        case en_ull_ref:
        case en_cl_reg:
            ep2->v.p[0] = repcallb(ep2->v.p[0]);
            break;
        case en_uminus:
        case en_bits:
        case en_asuminus:
        case en_ascompl:
        case en_not:
        case en_compl:
            ep2->v.p[0] = repcallb(ep2->v.p[0]);
            break;
        case en_cfc:
        case en_cfi:
        case en_crc:
        case en_cri:
        case en_clrc:
        case en_clri:
        case en_cb:
        case en_cub:
        case en_cbool:
        case en_cw:
        case en_cuw:
        case en_cl:
        case en_cul:
		case en_ci:
		case en_cui:
        case en_cll:
        case en_cull:
        case en_csp:
        case en_cf:
        case en_cd:
        case en_cp:
        case en_cld:
        case en_cfp:
            ep2->v.p[0] = repcallb(ep2->v.p[0]);
            break;
        case en_pfcallb:
        case en_sfcallb:
        case en_fcallb:
            {
                SYM *sp = ep2->v.p[1]->v.p[0]->v.p[1]->v.sp;
                ep2 = make_callblock(0, ep2, sp->tp->btp, sp->tp->btp->size);
                ep2 = repcallb(ep2);
            }
            break;
        case en_pfcall:
        case en_sfcall:
        case en_fcall:
        case en_stackblock:
        case en_assign:
        case en_intcall:
        case en_refassign:
        en_lassign: case en_add:
        case en_sub:
        case en_addstruc:
        en_addcast: case en_umul:
        case en_udiv:
        case en_umod:
        case en_mul:
        case en_div:
        case en_mod:
        case en_lsh:
        case en_asalsh:
        case en_asarsh:
        case en_alsh:
        case en_arsh:
        case en_arshd:
        case en_asarshd:
        case en_rsh:
        case en_and:
        case en_or:
        case en_xor:
        case en_land:
        case en_lor:
        case en_eq:
        case en_ne:
        case en_lt:
        case en_le:
        case en_ugt:
        case en_uge:
        case en_ult:
        case en_ule:
        case en_gt:
        case en_ge:
        case en_cond:
        case en_void:
        case en_voidnz:
        case en_dvoid:
        case en_asadd:
        case en_assub:
        case en_asmul:
        case en_asdiv:
        case en_asor:
        case en_asand:
        case en_asxor:
        case en_asmod:
        case en_aslsh:
        case en_asumod:
        case en_asudiv:
        case en_asumul:
        case en_pmul:
		case en_arrayindex:
        case en_asrsh:
        case en_pdiv:
        case en_moveblock:
        case en_repcons:
        case en_ainc:
        case en_adec:
		case en_array:
            ep2->v.p[1] = repcallb(ep2->v.p[1]);
        case en_trapcall:
        case en_substack:
        case en_clearblock:
            ep2->v.p[0] = repcallb(ep2->v.p[0]);
            break;
        case en_thiscall:
            switch (ep2->v.p[1]->nodetype)
            {
            case en_pfcallb:
            case en_sfcallb:
            case en_fcallb:
                {
                    SYM *sp = ep2->v.p[1]->v.p[1]->v.p[0]->v.p[1]->v.sp;
                    ep2 = make_callblock(0, ep2, sp->tp->btp, sp->tp->btp->size)
                        ;
                    ep2 = repcallb(ep2);
                }
                break;
            default:
                ep2->v.p[1] = repcallb(ep2->v.p[1]);
                ep2->v.p[0] = repcallb(ep2->v.p[0]);
                break;
            }
            break;
        case en_callblock:
        case en_pcallblock:
        case en_scallblock:
            // skip the struct function placeholder
            ep2->v.p[1]->v.p[1] = repcallb(ep2->v.p[1]->v.p[1]);
            ep2->v.p[1]->v.p[0] = repcallb(ep2->v.p[1]->v.p[0]);
            ep2->v.p[0] = repcallb(ep2->v.p[0]);
            break;
        default:
            DIAG("repcallb: unknown node type");
    }
    return ep2;
}

//-------------------------------------------------------------------------



ENODE *dummyvar(int size, TYP *type, char *name)
{
    char nm[20];
    ENODE *newnode;
    SYM *sp = makesym(sc_auto);
    if (name)
        sp->name = litlate(name);
    else
    {
        sprintf(nm, "**DUMMY%d", dumpos++);
        sp->name = litlate(nm);
    }
        sp->value.classdata.defalt = 0;
    type->uflags |= UF_USED;
    sp->tp = copytype(type, 0);
    sp->tp->cflags = 0;
    sp->extflag = FALSE;
    sp->absflag = FALSE;
    sp->intflag = FALSE;
    sp->faultflag = FALSE;
    sp->pascaldefn = FALSE;
    sp->isstdcall = FALSE;
    sp->init = 0;
    sp->indecltable = 0;
    sp->funcparm = 0;
    sp->inreg = 0;
    sp->mainsym = sp;
    if (currentfunc || indefaultinit)
    {
        sp->staticlabel = FALSE;
        sp->value.i = block_nesting;
        sp->storage_class = sc_auto;
        if (!indefaultinit)
            insert(sp, &lsyms);
        newnode = makenode(en_autocon, sp, 0);
    }
    else
    {
        /* have to do this for C++ constructor matching */
        sp->staticlabel = TRUE;
        sp->value.i = nextlabel++;
        sp->storage_class = sc_static;
        sp->tp->alignment = stddefalignment;
        insert_decl_sp(sp);
        insertSpace(sp, prm_bss ? &bssbytes: &databytes);
        newnode = makenode(en_nalabcon, sp, 0);
    }
    return newnode;
}

//-------------------------------------------------------------------------

int isintconst(int type)
{
    switch (type)
    {
        case en_icon:
        case en_lcon:
        case en_lucon:
        case en_iucon:
        case en_boolcon:
        case en_ccon:
        case en_cucon:
        case en_llcon:

        case en_llucon:
            return 1;
    }
    return 0;
}

//-------------------------------------------------------------------------

int isfloatconst(int type)
{
    switch (type)
    {
        case en_rcon:
        case en_fcon:
        case en_lrcon:
            return 1;
    }
    return 0;
}