expr.c

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

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

int isimaginaryconst(int type)
{
    switch (type)
    {
        case en_fimaginarycon:
        case en_rimaginarycon:
        case en_lrimaginarycon:
            return 1;
    }
    return 0;
}
int iscomplexconst(int type)
{
    switch (type)
    {
        case en_fcomplexcon:
        case en_rcomplexcon:
        case en_lrcomplexcon:
            return 1;
    }
    return 0;
}

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

int matchreflvalue(ENODE **node, TYP *tp1, TYP *tp2)
{
    if (node && ! *node || !exactype(tp1->btp, tp2,FALSE))
    {
        generror(ERR_REFLVALUE, 0, 0);
        return 0;
    }
    if (node)
        *node = (*node)->v.p[0];
    return 1;
}

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

ENODE *declRef(SYM *sp_in, TYP *tp1, TYP *tp2, ENODE *ep1, ENODE *ep2, int sc)
{
    char buf[256];
    int voidfunc = FALSE;
    SYM *sp = 0,  *spd = 0,  *sm,  *spx;
    TYP tpx, tpy;
    ENODE *pnode,  *rnode,  *tcnode = 0,  *epx;
    ENODE *location;
    ENODE *node = makenode(en_void, ep2, 0);
    {
        SYM *sp1 = search(cpp_funcname_tab[CI_CONSTRUCTOR], &sp_in->tp->btp
            ->lst);
        if (sp1)
        {
            sm = makesym(0);
            tpy.type = bt_func;
            tpy.lst.head = tpy.lst.tail = sm;
            sm->tp = tp2;
            sp = funcovermatch(sp1, &tpy, node, FALSE, FALSE);
        }
        sp1 = search(cpp_funcname_tab[CI_DESTRUCTOR], &sp_in->tp->btp->lst);
        if (sp1)
        {
            tpx.lst.head =  - 1;
            tpx.lst.tail =  - 1;
            tpx.type = bt_func;
            spd = funcovermatch(sp1, &tpx, 0, FALSE, FALSE);
        }
    }
    if (!sp && !spd)
        return 0;
    if (sc == sc_auto)
    {
        epx = dummyvar(tp1->btp->size, tp1->btp, 0);
    }
    else
    {
        spx = sm;
        sprintf(buf, "BDV_%d", dummyram++);
        spx->name = litlate(buf);
        spx->tp = copytype(tp1->btp, 0);
        insert_decl_sp(spx);
        insertSpace(spx, prm_bss ? &bssbytes: &databytes);
        epx = makenode(en_nacon, spx, 0);
    }
    deref(&epx, tp1->btp);
    gensymerror(ERR_TEMPINIT, sp_in->name);
    if (sp)
    {
        if (!isaccessible(sp))
            genclasserror(ERR_NOTACCESSIBLE, fullcppmangle(0, sp->name, 0));
        sp->mainsym->extflag = TRUE;
        pnode = makenode(en_napccon, sp, 0);
        parmlist(&node, &tpy, sp->tp);
        rnode = makenode(en_void, pnode, pnode);
        pnode = makenode(en_void, rnode, node);
        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);

        if (!(sp->value.classdata.cppflags &PF_STATIC))
            tcnode = epx;

        if (prm_cplusplus && tcnode && (sp->value.classdata.cppflags &PF_MEMBER)
            && !(sp->value.classdata.cppflags &PF_STATIC))
        {
            pnode = makenode(en_thiscall, tcnode, pnode);
        }
        pnode = doinline(pnode);
    }
    else
        pnode = makeintnode(en_icon, 0);
    pnode->cflags = tp1->cflags;
    pnode = makenode(en_conslabel, pnode, epx);
    if (sc == sc_auto)
    {
        if (indefaultinit)
        {
            if (expr_runup[expr_updowncount - 1])
                expr_runup[expr_updowncount - 1] = makenode(en_void,
                    expr_runup[expr_updowncount - 1], pnode);
            else
                expr_runup[expr_updowncount - 1] = pnode;
        }
        else
        {
            SNODE *snp = xalloc(sizeof(SNODE));
            snp->next = 0;
            snp->stype = st_expr;
            snp->exp = pnode;
            if (cbautoinithead == 0)
                cbautoinithead = cbautoinittail = snp;
            else
            {
                cbautoinittail->next = snp;
                cbautoinittail = snp;
            }
        }
    }
    else
    {
        cppinitinsert(pnode);
    }
    if (spd)
    {
        if (!isaccessible(spd))
            genclasserror(ERR_NOTACCESSIBLE, fullcppmangle(0, spd->name, 0));
        spd->mainsym->extflag = TRUE;
        if (!(spd->value.classdata.cppflags &PF_STATIC))
            tcnode = epx;
        if (spd->value.classdata.cppflags &PF_VIRTUAL)
        {
            ENODE *inode,  *nnode;
            inode = makeintnode(en_icon, spd->value.classdata.vtabindex);
            if (spd->value.classdata.vtaboffs)
                tcnode = makenode(en_add, tcnode, makeintnode(en_icon, spd
                    ->value.classdata.vtaboffs));
            nnode = makenode(en_a_ref, (void*)copy_enode(tcnode), 0);
            pnode = makenode(en_add, inode, nnode);
            pnode = makenode(en_a_ref, pnode, 0);
        }
        else
            pnode = makenode(en_napccon, spd, 0);
        rnode = makenode(en_void, pnode, makenode(en_napccon, spd, 0));
        pnode = makenode(en_void, rnode, makenode(en_void, 0, 0));
        rnode = makeintnode(en_icon, spd->tp->btp->size);
        if (spd->pascaldefn)
            pnode = makenode(en_pfcall, rnode, pnode);
        else
            if (spd->isstdcall)
                pnode = makenode(en_sfcall, rnode, pnode);
            else
                pnode = makenode(en_fcall, rnode, pnode);
        if (prm_cplusplus && tcnode && (spd->value.classdata.cppflags
            &PF_MEMBER) && !(spd->value.classdata.cppflags &PF_STATIC))
        {
            pnode = makenode(en_thiscall, tcnode, pnode);
        }
        pnode = doinline(pnode);

    }
    else
        pnode = makeintnode(en_icon, 0);

    pnode->cflags = tp1->cflags;
    pnode = makenode(en_destlabel, pnode, epx);
    if (sc == sc_auto)
    {
        if (indefaultinit)
            expr_rundown[expr_updowncount - 1] = makenode(en_void, pnode,
                expr_rundown[expr_updowncount - 1]);
        else if (block_rundown)
            block_rundown = makenode(en_void, pnode, block_rundown);
        else
            block_rundown = pnode;
    }
    else
    {
        cpprundowninsert(pnode);
    }
    return epx;
}

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

SYM *unnamed_search(char *na, SYM *cosym, int *offset)
{
    SYM *rv;
    cosym = cosym->tp->lst.head;
    while (cosym)
    {
        if (cosym->isunnamed)
        {
            rv = search(na, &cosym->tp->lst);
            if (!rv && cosym->tp->sp->hasunnamed)
                rv = unnamed_search(na, cosym, offset);
            if (rv)
            {
                *offset += cosym->value.i;
                return rv;
            }
        }
        cosym = cosym->next;
    }
    return 0;
}

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

TYP *nameref(ENODE **node, TYP *tin)
/*
 * get an identifier.  If it is followed by parenthesis gather the
 * function parms.  If it is an undefined function declare it as external
 * for now.
 *
 * For C++ also gather in the class type qualifier
 *
 */
{
    SYM *sp = 0,  *cosym = 0,  *sp1;
    TYP *tp,  *tp1;
    int reclass = FALSE;
    int dclasssel = FALSE;
    ENODE *pnode = 0,  *qnode = 0,  *xnode = 0;
    int offset = 0;
    int override = FALSE, member = FALSE;
    char buf[256], cobuf[256];
    int notbase = FALSE;
    cobuf[0] = 0;
    strcpy(buf, lastid);
    getsym();
    if (cantnewline)
    {
        *node = makeintnode(en_icon,0) ;
        return &stdint ;
    }
        if (typequal)
        {
            override = TRUE;
            cosym = typequal;
            if (declclass)
            {
                *node = xnode = makenode(en_a_ref, copynode(thisenode), 0);
            }
            else
                *node = xnode = 0;
            typequal = 0;
        }
        else
        {

            if (lastst == classsel)
            {
                override = TRUE;
                dclasssel = TRUE;
                cosym = typesearch(lastid);
                docls: if (cosym && cosym->storage_class != sc_namespace &&
                    cosym->storage_class != sc_type)
                    gensymerror(ERR_NOTNSORTYPQUAL, cosym->name);
                getsym();
                if (lastst == kw_operator)
                {
                    TYP *tp2;
                    getsym();
                    return dooperator(&node);
                }
                else
                {
                    if (declclass)
                    {
                        *node = xnode = makenode(en_a_ref, copynode(thisenode),
                            0);
                    }
                    else
                    {
                        *node = xnode = makeintnode(en_icon, 0); /* better be a
                            member ptr ref if we get here */
                    }
                    if (!cosym || !isstructured(cosym->tp) && cosym
                        ->storage_class != sc_namespace)
                        generror(ERR_TYPEQUALEXP, 0, 0);

                    if (lastst != id)
                    {
                        *node = makeintnode(en_icon,  - 4);
                        return  &stdint;
                    }
                    strcpy(buf, lastid);
                    getsym();
                }
            }
            else
            {
                ENODE *ynode =  *node;
                if (tin && tin->type == bt_ref)
                {
                    ynode = makenode(en_a_ref, ynode, 0);
                    tin = tin->btp;
                }
                if (tin && isstructured(tin))
                {
                    override = TRUE;
                    cosym = tin->sp;
                    xnode = ynode;
                }
                else if (declclass)
                {
                    cosym = declclass;
                    *node = xnode = makenode(en_a_ref, copynode(thisenode), 0);
                    reclass = TRUE;
                }
            }
        }
        if (cosym)
            strcpy(cobuf, cosym->name);
        join: 
    nm = litlate(buf);
        if (!sp)
        if (cosym)
        {
            if (!override)
                sp = search(buf, &lsyms);
            if (sp)
            {
                cosym = 0;
                xnode = 0;
            }
            else
            {
                if (cosym->storage_class == sc_namespace)
                {
                    if (parsing_params)
                    {
                       
                            parm_namespaces[parm_ns_level][parm_ns_counts[parm_ns_level]++] = cosym;
                    }
                    sp = namespace_search(buf, cosym->value.classdata.parentns,
                        0);
                    if (!sp)
                        sp = namespace_search(buf, cosym
                            ->value.classdata.parentns, 1);
                    override = FALSE;
                }
                else
                {
                    sp = basesearch(buf, &cosym->tp->lst.head, TRUE);
                    if (!sp && cosym->hasunnamed)
                        sp = unnamed_search(buf, cosym, &offset);
                    if (!sp && cosym->parentclass)
                    {
                        SYM *sp2 = cosym->parentclass;
                        while (sp2)
                        {
                            sp = basesearch(buf, &sp2->tp->lst.head, TRUE);
                            if (sp)
                            {
                                if (!(sp->value.classdata.cppflags &PF_STATIC))
                                    gensymerror(ERR_STATICNOACCESS, sp->name);
                                break;
                            }
                            sp2 = sp2->parentclass;
                        }
                    }
                    if (!sp)
                        if (!override)
                            sp = typesearch(buf);
                        else
                            generror(ERR_MEMBERNAMEEXP, 0, 0);
                }
            }
        }
        else
        sp = typesearch(buf);

    if (prm_cplusplus && override && cosym && !(cosym->value.classdata.cppflags
        &PF_STATIC))
        member = TRUE;
    if (sp == 0)
    {
        /* No such identifier */
        if (lastst == openpa)
        {
            /* External function, put it in the symbol table */
            ++global_flag;
            sp = makesym(sc_externalfunc);
            sp->name = litlate(buf);
            sp->tp = maketype(bt_func, 0);
            *(sp->tp) = stdfunc;
            sp->tp->sp = sp;
            sp->mainsym->extflag = TRUE;
            setalias(sp);
            *node = makenode(en_nacon, sp, 0);
                //                                    if (cosym)
                //                                       insert(sp,&cosym->tp->lst.head);
                //                                    else
            insert(sp, gsyms);
            --global_flag;
            tp = sp->tp;
            goodcode |= GF_ASSIGN;
        }
        else