decl.c

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

                    if (argcount != 1 && argcount != 2)
                        gensymerror(ERR_DECL2ARG, sp->name);
                    else
                        if (!isclassarg(sp))
                            gensymerror(ERR_OPERATORMUSTCLASS, sp->name);
                break;
            case ov_autoinc:
            case ov_autodec:
                if (typequal || declclass)
                {
                    if (argcount > 1)
                        gensymerror(ERR_DECL0OR1ARG, sp->name);
                    else if (argcount && sp->tp->lst.tail->tp->type != bt_int)
                        gensymerror(ERR_OVPOSTFIXINTLAST, sp->name);
                }
                else
                    if (argcount > 2 || argcount < 1)
                        gensymerror(ERR_DECL1OR2ARG, sp->name);
                    else
                {
                    if (!isclassarg(sp))
                            gensymerror(ERR_OPERATORMUSTCLASS, sp->name);
                        else if (argcount == 2 && sp->tp->lst.tail->tp->type !=
                            bt_int)
                            gensymerror(ERR_OVPOSTFIXINTLAST, sp->name);
                }
                break;
            case ov_cpl:
            case ov_not:
                if (typequal || declclass)
                {
                    if (argcount)
                        gensymerror(ERR_DECL0ARG, sp->name);
                }
                else
                    if (argcount != 1)
                        gensymerror(ERR_DECL1ARG, sp->name);
                    else
                        if (!isclassarg(sp))
                            gensymerror(ERR_OPERATORMUSTCLASS, sp->name);
                break;

            case ov_ind:
                if (!typequal && !declclass)
                    gensymerror(ERR_OPMUSTBEMEMBER, sp->name);
                else
                    if (argcount != 1)
                        gensymerror(ERR_DECL1ARG, sp->name);
                break;
            case ov_arg:
                if (!typequal && !declclass)
                    gensymerror(ERR_OPMUSTBEMEMBER, sp->name);
                else
                    if (argcount)
                        gensymerror(ERR_DECL0ARG, sp->name);
                break;
            case ov_pstar:
            case ov_arr:
                if (!typequal && !declclass)
                    gensymerror(ERR_OPMUSTBEMEMBER, sp->name);
                else
                    if (argcount)
                        gensymerror(ERR_DECL0ARG, sp->name);
                    else
                {
                    TYP *tp = sp->tp->btp;
                    if (tp->type != bt_segpointer && tp->type != bt_pointer &&
                        tp->type != bt_farpointer || !isstructured(tp->btp))
                            gensymerror(ERR_POINTTOCLASS, sp->name);
                }
                break;
        }
    }
    ENODE *do_constructor(SYM *sp_in, TYP *tp, TYP *head1, ENODE *node, int
        size, int offset, int assn, int implicit)
    {
        char buf[256];
        int voidfunc = FALSE;
        SYM *sp;
        ENODE *pnode,  *rnode,  *tcnode = 0;
        if (incatchclause)
            return 0;
        if (tp->lst.head == (SYM*) - 1)
            voidfunc = TRUE;
        {
            SYM *sp1 = search(cpp_funcname_tab[CI_CONSTRUCTOR], &head1->lst);
            if (!sp1)
            {
                if (!voidfunc && !assn)

                    gensymerrorexp(ERR_NOFUNCMATCH, fullcppmangle(head1->sp,
                        cpp_funcname_tab[CI_CONSTRUCTOR], tp));
                return 0;
            }
            sp = funcovermatch(sp1, tp, node, FALSE, FALSE);
            if (!sp)
            {
                if (!assn)
                    gensymerrorexp(ERR_NOFUNCMATCH, fullcppmangle(head1->sp,
                        cpp_funcname_tab[CI_CONSTRUCTOR], tp));
                return 0;
            }
            pnode = makenode(en_napccon, sp, 0);
        }
        if (!isaccessible(sp))
            genclasserror(ERR_NOTACCESSIBLE, fullcppmangle(sp->parentclass
                ->parentclass, sp->name, 0));
        if (implicit && (sp->value.classdata.cppflags &PF_EXPLICIT))
            generror(ERR_NOEXPLICITHERE, 0, 0);
        sp->mainsym->extflag = TRUE;
        parmlist(&node, tp, 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))
            if (sp_in->storage_class == sc_type)
                tcnode = makenode(en_a_ref, copynode(thisenode), 0);
            else if (sp_in->storage_class == sc_auto)
                tcnode = makenode(en_autocon, sp_in, 0);
            else if (sp_in->storage_class == sc_autoreg)
                tcnode = makenode(en_autoreg, sp_in, 0);
            else
                tcnode = makenode(en_nacon, sp_in, 0);
        if (offset)
            tcnode = makenode(en_addstruc, (void*)tcnode, makeintnode(en_icon,
                offset));
            if (prm_cplusplus && tcnode && (sp->value.classdata.cppflags
                &PF_MEMBER) && !(sp->value.classdata.cppflags &PF_STATIC))
            {
                pnode = makenode(en_thiscall, tcnode, pnode);
            }
            if (size == 1)
                pnode = doinline(pnode);
            else
            {
                ENODE *snode;
                snode = makeintnode(en_icon, head1->size);
                snode = makenode(en_void, makeintnode(en_icon, size), (void*)
                    snode);
                pnode = makenode(en_repcons, (void*)snode, (void*)pnode);
                SetExtFlag(sp, TRUE);
            }
            pnode->cflags = head1->cflags;
            pnode = makenode(en_conslabel, pnode, makenode(en_autocon, (void*)
                sp_in->mainsym, 0));
        conscount++;
        sp_in->mainsym->constructed = 1 ;
        return pnode;

    }
    ENODE *do_destructor(SYM *sp_in, TYP *tp, TYP *head1, ENODE *xnode, int
        size, int offset, int assn)
    {
        char buf[256];
        ENODE *node = 0;
        SYM *sp;
        ENODE *pnode,  *rnode,  *tcnode = 0;
        if (incatchclause)
            return 0;
        {
            SYM *sp1 = search(cpp_funcname_tab[CI_DESTRUCTOR], &head1->lst);
            if (!sp1)
            {
                return 0;
            }
            sp = funcovermatch(sp1, tp, xnode, FALSE, FALSE);
            if (!sp)
            {
                if (!assn)
                    gensymerrorexp(ERR_NOFUNCMATCH, fullcppmangle(tp->sp,
                        cpp_funcname_tab[CI_DESTRUCTOR], tp));
                return 0;
            }
            pnode = makenode(en_napccon, sp, 0);
        }
        sp->mainsym->extflag = TRUE;
        if (xnode)
            tcnode = xnode;
        else
        {
            if (!(sp->value.classdata.cppflags &PF_STATIC))
                if (sp_in->storage_class == sc_auto)
                    tcnode = makenode(en_autocon, sp_in, 0);
                else if (sp_in->storage_class == sc_autoreg)
                    tcnode = makenode(en_autoreg, sp_in, 0);
                else
                    tcnode = makenode(en_nacon, sp_in, 0);
            if (offset)
                tcnode = makenode(en_addstruc, (void*)tcnode, makeintnode
                    (en_icon, offset));
        }
        if (!isaccessible(sp))
            genclasserror(ERR_NOTACCESSIBLE, fullcppmangle(sp->parentclass
                ->parentclass, sp->name, 0));
        if (sp->value.classdata.cppflags &PF_VIRTUAL)
        {
            ENODE *inode,  *nnode;
            inode = makeintnode(en_icon, sp->value.classdata.vtabindex);
            if (sp->value.classdata.vtaboffs)
                tcnode = makenode(en_add, tcnode, makeintnode(en_icon, sp
                    ->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);
        }
        parmlist(&node, tp, 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 (prm_cplusplus && tcnode && (sp->value.classdata.cppflags
                &PF_MEMBER) && !(sp->value.classdata.cppflags &PF_STATIC))
            {
                pnode = makenode(en_thiscall, tcnode, pnode);
            }
            if (size == 1)
                pnode = doinline(pnode);
            else
            {
                ENODE *snode;
                snode = makeintnode(en_icon, head1->size);
                snode = makenode(en_void, makeintnode(en_icon, size), (void*)
                    snode);
                pnode = makenode(en_repcons, (void*)snode, (void*)pnode);
                SetExtFlag(sp, TRUE);
            }
            pnode = makenode(en_destlabel, pnode, makenode(en_autocon, (void*)
                sp_in->mainsym, 0));
        pnode->cflags = head1->cflags;
        conscount++;
        return pnode;

    }
    ENODE **actualexpr(ENODE **qnode)
    {
        ENODE **rv;
        if (! *qnode)
            return 0;
        if ((*qnode)->nodetype == en_void || ((*qnode)->nodetype == en_dvoid))
        {
            if ((*qnode)->cflags &DF_ACTUALEXPR)
                return qnode;
            rv = actualexpr(&(*qnode)->v.p[0]);
            if (rv)
                return rv;
            rv = actualexpr(&(*qnode)->v.p[1]);
            if (rv)
                return rv;
        }
        return 0;
    }
    int conspair(SYM *sp, enum e_sc al, int flag, TYP *tp1, ENODE *qnode, int
        assn, int offs, int implicit)
    {
        ENODE **actual = actualexpr(&qnode),  *qn1,  *qnode1;
        TYP tp2,  *tp3 =  *headptr;
        SYM *sp2;
        ENODE *en2,  *en3;
        int size = 1;
        if (infuncargs && !indefaultinit)
            return 1;
        if (indefaultinit)
        {
            sp->value.classdata.defalt = xalloc(sizeof(DEFVALUE));
            en2 = dummyvar(head->size, head, 0);
            sp2 = en2->v.sp;
            //                                          en3 = makenode(en_autocon,(void *)sp,0) ;
            //                                          en3 = makenode(en_moveblock,en3,en2) ;
            //                                          en3->size = head->size ;
            sp->value.classdata.defalt->ep = en2;
        } 
        else
            sp2 = sp;
        if (flag)
        {
            while (tp3->type == bt_pointer || tp3->type == bt_farpointer || tp3
                ->type == bt_segpointer)
            {
                size = decl3size;
                tp3 = tp3->btp;
            }
        }
        expr_runup[expr_updowncount] = 0;
        expr_rundown[expr_updowncount++] = 0;
        qn1 = do_constructor(sp2, tp1, tp3, actual ? (*actual): qnode, flag < 0
            ?  - flag: size, offs, assn, implicit);
        expr_updowncount--;
        if (expr_runup[expr_updowncount] || expr_rundown[expr_updowncount])
        {
            qn1 = makenode(en_dvoid, qn1, expr_rundown[expr_updowncount]);
            (qn1)->cflags |= DF_ACTUALEXPR;
        }
        if (expr_runup[expr_updowncount])
            qn1 = makenode(en_void, expr_runup[expr_updowncount], qn1);
        if (actual)
            (*actual)->v.p[0] = qn1;
        else
            qnode = qn1;
        tp2.lst.head =  - 1;
        tp2.lst.tail =  - 1;
        tp2.type = bt_func;
        qnode1 = do_destructor(sp2, &tp2, tp3, 0, flag < 0 ?  - flag: size,
            offs, FALSE);
        if (qnode1 && !qnode)
            qnode = makenode(en_conslabel, makeintnode(en_icon, 0), makenode
                (en_autocon, (void*)sp2->mainsym, 0));

        if (qnode)
        {
            if (indefaultinit)
            {
                sp->value.classdata.defalt->cons = qnode;
            }
            else if (al == sc_auto)
            {
                SNODE *snp = xalloc(sizeof(SNODE));
                snp->next = 0;
                snp->stype = st_expr;
                snp->exp = qnode;
                if (cbautoinithead == 0)
                    cbautoinithead = cbautoinittail = snp;
                else
                {
                    cbautoinittail->next = snp;
                    cbautoinittail = snp;
                }
            }
            else
            {
                cppinitinsert(qnode);
            }
        }
        if (qnode && !qnode1)
            qnode1 = makenode(en_destlabel, makeintnode(en_icon, 0), makenode
                (en_autocon, (void*)sp2->mainsym, 0));
        if (qnode1)
        {
            if (indefaultinit)
            {
                sp->value.classdata.defalt->dest = makenode(en_destlabel,
                    makeintnode(en_icon, 0), makenode(en_autocon, (void*)sp2
                    ->mainsym, 0));
            }
            else if (al == sc_auto)
            {
                if (block_rundown)
                    block_rundown = makenode(en_void, qnode1, block_rundown);
                else
                    block_rundown = qnode1;
            }
            else
            {
                cpprundowninsert(qnode1);
            }
        }
        return 1;
    }
void decl2(enum e_sc sc, SYM *sp)
/*
 * type modifiers that come AFTER the name of the variable
 */
{
    TYP *temp1,  *head1 =  *headptr;
    TYP *otc = typequal;
    int ocppf;
    int odflt;
    int otemp;
    char localid[128];
    typequal = 0;
    if (prm_cplusplus)
    {
        temp1 = head;
        while (temp1->type == bt_ref || temp1->type == bt_pointer || temp1
            ->type == bt_farpointer || temp1->type == bt_se