declass.c

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

                            lst->data = sp2;
                        }
                        else
                            lst->data = sp;
                        SetExtFlag(sp, TRUE);
                        sp->value.classdata.vtabindex = sp1
                            ->value.classdata.vtabindex;
                        sp->value.classdata.vtaboffs = sp1
                            ->value.classdata.vtaboffs;
                        return ;
                    }
                }
                lst = lst->link;
            }
        }
        l = cl->value.classdata.baseclass;
        l->flags |= CL_VTAB;
        lst = &l->vtablist;
        while (*lst)
            lst = &(*lst)->link;
        *lst = xalloc(sizeof(LIST));
        (*lst)->link = 0;
        (*lst)->data = sp;
        sp->value.classdata.vtabindex = l->vtabsize - vtabhead;
        sp->value.classdata.vtaboffs = l->offset;
        l->vtabsize += stdaddrsize;
    }
    void classerrs(SYM *sp)
    {
        SYM *head = sp->tp->lst.head;
        int hasref = FALSE;
        while (head)
        {
            if (!(head->value.classdata.cppflags &PF_INHERITED) && !(sp
                ->value.classdata.cppflags &PF_HASCONS))
            {
                if (head->tp->type == bt_ref)
                    genclass2error(ERR_REFNOCONS, head->parentclass->name, head
                        ->name);
                else if (head->tp->cflags &DF_CONST)
                    genclass2error(ERR_CONSTNOCONS, head->parentclass->name,
                        head->name);
            }
            head->parentclass = sp;
            head = head->next;
        }
    }
    ENODE *conscall(ENODE *tcnode, SYM *sp, ENODE *ep)
    {
        ENODE *pnode,  *rnode,  *runup = 0,  *rundown = 0;
        pnode = makenode(en_napccon, sp, 0);
        sp->mainsym->extflag = TRUE;
        if (!ep)
        {
            SYM *t = sp->tp->lst.head;
            if (!t || t == (SYM*) - 1)
                ep = makenode(en_void, 0, 0);
            else
            {
                while (t)
                {
                    ep = makenode(en_void, copy_default(t
                        ->value.classdata.defalt->ep), ep);
                    if (t->value.classdata.defalt->cons)
                        if (runup)
                            runup = makenode(en_void, runup, copy_default(t
                                ->value.classdata.defalt->cons));
                        else
                            runup = copy_default(t->value.classdata.defalt
                                ->cons);
                    if (t->value.classdata.defalt->dest)
                        rundown = makenode(en_void, copy_default(t
                            ->value.classdata.defalt->dest), rundown);
                    t = t->next;
                }
                ep = makenode(en_void, ep, 0);
            }
        }
        rnode = makenode(en_void, pnode, pnode);
        pnode = makenode(en_void, rnode, ep);
        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);
        if (runup || rundown)
        {
            pnode = makenode(en_dvoid, pnode, rundown);
            pnode->cflags |= DF_ACTUALEXPR;
        }
        if (runup)
            pnode = makenode(en_void, runup, pnode);
        return pnode;
    }
    void setthunkflags(SYM *sp_in, int state)
    {
        CLASSLIST *l = sp_in->value.classdata.enclosedclass;
        return ;
        while (l)
        {
            setthunkflags(l->data->tp->sp, state);
            l = l->link;
        }
        l = sp_in->value.classdata.baseclass;
        while (l)
        {
            if (!state)
                l->data->value.classdata.cppflags &= ~PF_TEMPCONSALREADY;
            else
                l->data->value.classdata.cppflags |= PF_TEMPCONSALREADY;
            l = l->link;
        }
    }
    void curcons(SYM *sp_in, SYM *vtabsp, ENODE **exps, CLASSLIST *l, ENODE
        *thisn, int checkaccess, int ofs)
    {
        ENODE *exp1,  *exp2,  *ts;
        //   if (l->link)
        //      curcons(sp_in,vtabsp,exps,l->link,thisn,checkaccess,ofs) ;
        while (l)
        {
            if ((l->flags &CL_VTAB) && !(l->flags &CL_TOPCLASS))
            {
                if (checkaccess)
                {
                    SYM *sp1 = search(cpp_funcname_tab[CI_CONSTRUCTOR], &l
                        ->data->tp->lst);
                    if (sp1)
                    {
                        sp1 = funcovermatch(sp1, &functovoidtype, 0, FALSE,
                            FALSE);
                        if (sp1)
                            if (!isaccessible(sp1))
                                genclasserror(ERR_NOTACCESSIBLE, fullcppmangle
                                    (sp1->parentclass, sp1->name, 0));

                    }
                    else
                    // should never get here
                        gensymerror(ERR_NOFUNCMATCH, fullcppmangle(sp_in,
                            cpp_funcname_tab[CI_CONSTRUCTOR], &stdvoidfunc));
                }
                ts = makenode(en_nacon, vtabsp, 0);
                exp1 = makenode(en_addstruc, ts, makeintnode(en_icon, l
                    ->vtaboffs + vtabhead));
                exp2 = makenode(en_addstruc, thisn, makeintnode(en_icon, (l
                    ->offset + ofs)));
                exp2 = makenode(en_a_ref, exp2, 0);
                exp2 = makenode(en_assign, exp2, exp1);
                if (! *exps)
                    *exps = exp2;
                else
                    *exps = makenode(en_void, (void*)exp2, (void*) * exps);
            }
            l = l->link;
        }
    }
    void prevcons(SYM *sp_in, ENODE **exps, CLASSLIST *l, ENODE *thisn, int
        checkaccess, int ofs)
    {
        ENODE *exp1,  *exp2,  *ts;
        while (l)
        {
            if (l->data->value.classdata.consbuild)
            {
                exp2 = l->data->value.classdata.consbuild;
                l->data->value.classdata.consbuild = 0;
                setthunkflags(l->data->tp->sp, TRUE);
                if (! *exps)
                    *exps = exp2;
                else
                    *exps = makenode(en_void, (void*)exp2, (void*) * exps);
            }
            else
            {
                if (l->flags &CL_PRIMARY)
                {
                    SYM *sp1 = search(cpp_funcname_tab[CI_CONSTRUCTOR], &l
                        ->data->tp->lst);
                    if (sp1)
                    {
                        SYM *sp2 = funcovermatch(sp1, &functovoidtype, 0, FALSE,
                            FALSE);
                        if (!sp2)
                            gensymerror(ERR_NOFUNCMATCH, fullcppmangle(sp1,
                                cpp_funcname_tab[CI_CONSTRUCTOR], &stdvoidfunc))
                                ;
                        else
                        {
                            if (!isaccessible(sp2))
                                genclasserror(ERR_NOTACCESSIBLE, fullcppmangle
                                    (sp1->parentclass, sp1->name, 0));
                            exp2 = makenode(en_addstruc, thisn, makeintnode
                                (en_icon, (l->offset + ofs)));
                            exp2 = conscall(exp2, sp2, 0);
                            setthunkflags(l->data->tp->sp, TRUE);
                            if (! *exps)
                                *exps = exp2;
                            else
                                *exps = makenode(en_void, (void*)exp2, (void*)
                                    * exps);
                        }
                    } //else // should never get here
                    //        gensymerror(ERR_NOFUNCMATCH,fullcppmangle(l->data,cpp_funcname_tab[CI_CONSTRUCTOR],&stdvoidfunc)) ; 
                }
            }
            l = l->link;
        }
    }
    void embeddedcons(SYM *sp_in, SNODE *snp3, ENODE **exps, ENODE *thisn)
    {
        SYM *spt = sp_in->tp->lst.head;
        ENODE *exp1,  *exp2;
        while (spt)
        {
            if (!(spt->value.classdata.cppflags &PF_INHERITED))
            {
                if (spt->value.classdata.consbuild)
                {
                    exp1 = spt->value.classdata.consbuild;
                    if (isstructured(spt->tp))
                    {
                        setthunkflags(spt->tp->sp, TRUE);
                    }
                    else
                    {
                        if (spt->tp->type == bt_ref)
                        {
                            spt->value.classdata.cppflags |=
                                PF_TEMPCONSREFALREADY;
                            if (!lvalue(exp1))
                                generror(ERR_REFLVALUE, 0, 0);
                            else
                                exp1 = exp1->v.p[0];
                        }
                        if (spt->tp->cflags &DF_CONST)
                            spt->value.classdata.cppflags |=
                                PF_TEMPCONSREFALREADY;
                        exp2 = makenode(en_addstruc, (void*)thisn, (void*)
                            makeintnode(en_icon, spt->value.i));
                        exp2 = makenode(en_a_ref, (void*)exp2, 0);
                        exp1 = makenode(en_assign, (void*)exp2, (void*)exp1);
                    }
                    if (!snp3->exp)
                        snp3->exp = exp1;
                    else
                        snp3->exp = makenode(en_void, (void*)snp3->exp, (void*)
                            exp1);
                    spt->value.classdata.consbuild = 0;
                }
                else if (spt->storage_class == sc_member && isstructured(spt
                    ->tp))
                {
                    SYM *sp1 = search(cpp_funcname_tab[CI_CONSTRUCTOR], &spt
                        ->tp->lst);
                    if (sp1)
                    {
                        SYM *sp2 = funcovermatch(sp1, &functovoidtype, 0, FALSE,
                            FALSE);
                        if (!sp2)
                            gensymerror(ERR_NOFUNCMATCH, fullcppmangle(sp1,
                                cpp_funcname_tab[CI_CONSTRUCTOR], &stdvoidfunc))
                                ;
                        else
                        {
                            if (!isaccessible(sp2))
                                genclasserror(ERR_NOTACCESSIBLE, fullcppmangle
                                    (sp1->parentclass, sp1->name, 0));
                            exp2 = makenode(en_addstruc, thisn, makeintnode
                                (en_icon, (spt->value.i)));
                            exp2 = conscall(exp2, sp2, 0);
                            setthunkflags(spt, TRUE);
                            if (! *exps)
                                *exps = exp2;
                            else
                                *exps = makenode(en_void, (void*)exp2, (void*)
                                    * exps);
                        }
                    } //else // should never get here
                    //              gensymerror(ERR_NOFUNCMATCH,fullcppmangle(spt,cpp_funcname_tab[CI_CONSTRUCTOR],&stdvoidfunc)) ; 
                }
            }
            spt = spt->next;
        }
    }
    SYM *lookupcopycons(SYM *sp_in, SYM **spr)
    {
        SYM *sp1 = search(cpp_funcname_tab[CI_CONSTRUCTOR], &sp_in->tp->lst);
        if (spr)
            *spr = sp1;
        if (sp1)
        {
            sp1 = sp1->tp->lst.head;
            while (sp1)
            {
                SYM *sp2 = sp1->tp->lst.head;
                if (sp2 != 0 && sp2 !=  - 1 && sp2->next == 0)
                    if (sp2->tp->type == bt_ref && isstructured(sp2->tp->btp)
                        && sp2->tp->btp->sp->mainsym == sp_in->mainsym)
                        return sp1;
                sp1 = sp1->next;
            }
        }
        return 0;
    }
    void prevcopycons(SYM *sp_in, ENODE *argn, ENODE **exps, CLASSLIST *l,
        ENODE *thisn, int checkaccess, int ofs)
    {
        ENODE *exp1,  *exp2,  *ts;
        while (l)
        {
            if (l->flags &CL_PRIMARY)
            {
                    SYM *sp1;
                    SYM *sp2 = lookupcopycons(l->data, &sp1);
                    if (!sp2) {
                        gensymerror(ERR_NOFUNCMATCH, fullcppmangle(sp1,
                            cpp_funcname_tab[CI_CONSTRUCTOR], &stdvoidfunc));
                        
                    }
                    else
                    {
                        if (!isaccessible(sp2))
                            genclasserror(ERR_NOTACCESSIBLE, fullcppmangle(sp1
                                ->parentclass, sp1->name, 0));
                        exp2 = makenode(en_addstruc, thisn, makeintnode(en_icon,
                            (l->offset + ofs)));
                        exp2 = conscall(exp2, sp2, argn);
                        if (! *exps)
                            *exps = exp2;
                        else
                            *exps = makenode(en_void, (void*)exp2, (void*) *
                                exps);
                    }
            }
            l = l->link;
        }
    }
    void embeddedcopycons(SYM *sp_in, ENODE *argn, SNODE *snp3, ENODE **exps,
        ENODE *thisn)
    {
        SYM *spt = sp_in->tp->lst.head;
        ENODE *exp1,  *exp2;
        int offset =  - 1;
        while (spt)
        {
            if (!(spt->value.classdata.cppflags &PF_INHERITED))
            {
                if (spt->storage_class == sc_member && isstructured(spt->tp))
                {
                    SYM *sp1;
                    SYM *sp2 = lookupcopycons(spt->tp->sp, &sp1);
                    if (offset !=  - 1)
                    {
                        exp2 = makenode(en_addstruc, thisn, makeintnode(en_icon,
                            (offset)));
                        exp1 = makenode(en_addstruc, argn, makeintnode(en_icon,
                            (offset)));
                        exp2 = makenode(en_moveblock, exp2, exp1);
                        exp2->size = spt->value.i - offset;
                        if (! *exps)
                            *exps = exp2;
                        else
                            *exps = makenode(en_void, (void*)exp2, (void*) *
                                exps);
                        offset =  - 1;
                    }
                    if (!sp2)
                    {
                        gensymerror(ERR_NOFUNCMATCH, fullcppmangle(sp1,
                            cpp_funcname_tab[CI_CONSTRUCTOR], &stdvoidfunc));
                    }
                    else
                    {
                        if (!isaccessible(sp2))
                            genclasserror(ERR_NOTACCESSIBLE, fullcppmangle(sp1
                                ->parentclass, sp1->name, 0));
                        exp2 = makenode(en_addstruc, thisn, makeintnode(en_icon,
                            (spt->value.i)));
                        exp2 = conscall(exp2, sp2, makenode(en_void,makenode(en_a_ref,argn,0),0));
                        if (! *exps)
                            *exps = exp2;
                        else
                            *exps = makenode(en_void, (void*)exp2, (void*) *
                                exps);
                    }
                }
                else if (offset ==  - 1 && spt->storage_class == sc_member &&
                    isscalar(spt->tp))
                    offset = spt->value.i ;
            }
            else if (isscalar(spt->tp) || isstructured(spt->tp))
                offset = spt->value.i ;
            spt = spt->next;
        }