einit.c

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

            {
                ep2->v.p[0] = ep1;
                ep1 = ep2;
            }
            else
            {
                ep1 = makenode(en_moveblock, ep1, ep2);
                ep1->size = tp->size;
            }
            cppinitinsert(ep1);
        }
        return tp->size;
    }
    if (begin_nesting == 1)
    {
        if (!needpunc(begin,skm_declend))
            return tp->size;       
    }
    else
        if (lastst == begin)
            getsym() ;
        else
            has_begin = FALSE;
    nbytes = 0;
    sp = tp->lst.head; /* start at top of symbol table */
    if (lastst == end)
        generror(ERR_ILLINIT,0,0);
    while (lastst != end && lastst != eof)
    {
        int ooffset = baseoffset;
        if (prm_c99 && lastst == dot) 
        {
            getsym() ;
            if (lastst == id) 
            {
                SYM *sp1 = tp->lst.head ;
                while (sp1) {
                    if (!strcmp(sp1->name,lastid)) 
                        break ;
                    sp1 = sp1->next;
                }
                if (!sp1)
                    gensymerror(ERR_UNDEFINED,lastid) ;
                else
                    sp = sp1;
                getsym();
                needpunc(assign,0);
            }
            else
                gensymerror(ERR_UNDEFINED,lastid) ;
        } 
        if (sp == 0)
            break;
        sptr = &sp->init;
        sp->init = 0;
        baseoffset += sp->value.i;
        startbit = sp->tp->startbit;
        bits = sp->tp->bits;
        einittype(sp->tp);

        baseoffset = ooffset ;    
        sp = sp->next;
        if (lastst == comma)
            if (sp)
                getsym();
            else if (has_begin)
                if (!sp)
                {
                    getsym();
                    break ;
                }
                else
                    getsym();
            else
                break;
        else if (!sp || lastst == end)
            break;
        else
            expecttoken(end, 0);
    }
    sp = tp->lst.head; /* start at top of symbol table */
    sptr = osptr;
    while (sp) {
        *sptr = sp->init;
        while (*sptr)
            sptr = &(*sptr)->v.p[1];
        sp->init = 0;
        sp = sp->next;
    }
    if (has_begin)
        needpunc(end, skm_declend);
    return tp->size;
}

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


/* handle floating point einit
 */
ENODE *ecppfloat(void)
{
    TYP *t1;
    ENODE *ep;
    allocated = TRUE;

        t1 = exprnc(&ep);
        if (isintconst(ep->nodetype))
            return ep;
        else if (isfloatconst(ep->nodetype))
            return ep;
        else
        {
            if (!isscalar(t1) || !ep)
                generror(ERR_NEEDCONST, 0, 0);
            else
            {
                return ep ;
            }
        }
        return 0;
}

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

ENODE *ecppint(void)
{
    TYP *t1;
    ENODE *ep;
    LLONG_TYPE val = 0;
    int done = TRUE;
    allocated = TRUE;
        {
            int began = 0;
            done = FALSE;
            if (lastst == begin)
            {
                began++;
                getsym();
            }
            t1 = exprnc(&ep);
            opt4(&ep);
            if (began)
                needpunc(end, 0);
            if (!ep)
            {
                generror(ERR_ILLINIT, 0, 0);
                return 0;
            }
            if (isintconst(ep->nodetype))
                return ep ;
            else if (isfloatconst(ep->nodetype)) {
                ep->nodetype = en_icon;
                ep->v.i = ep->v.f;
                return ep;
            } 
            else
            {
                val = 0;
                if (!isscalar(t1) || !ep)
                    generror(ERR_NEEDCONST, 0, 0);
                else
                {
                    return ep;
                }
            }
        }
        return 0;
}

/* Basic type subroutines */
int einitfcomplex(void)
{
    TYP tp;
    tp.type = bt_float;
    if (lastst == begin)
    {
        initassign(ecppfloat(),baseoffset,&tp) ;
        if (lastst == comma)
        {
            getsym();
            initassign(ecppfloat(),baseoffset+4,&tp) ;
        } 
        else {
            ENODE *ep = makenode(en_fcon,0,0) ;
            ep->v.f = 0.0;
            initassign(ep,baseoffset+stdfloatsize,&tp) ;
        }
        needpunc(end, 0);
    }
    else
    {
        ENODE *ep = makenode(en_fcon,0,0) ;
        initassign(ecppfloat(),baseoffset,&tp) ;
        ep->v.f = 0.0;
        initassign(ep,baseoffset+stdfloatsize,&tp) ;
    }
    return stdfloatsize * 2;
}

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

/* Basic type subroutines */
int einitlrcomplex(void)
{
    TYP tp;
    tp.type = bt_longdouble;
    if (lastst == begin)
    {
        initassign(ecppfloat(),baseoffset,&tp) ;
        if (lastst == comma)
        {
            getsym();
            initassign(ecppfloat(),baseoffset+stddoublesize,&tp) ;
        } 
        else {
            ENODE *ep = makenode(en_fcon,0,0) ;
            ep->v.f = 0.0;
            initassign(ep,baseoffset+stdldoublesize,&tp) ;
        }
        needpunc(end, 0);
    }
    else
    {
        ENODE *ep = makenode(en_fcon,0,0) ;
        initassign(ecppfloat(),baseoffset,&tp) ;
        ep->v.f = 0.0;
        initassign(ep,baseoffset+stdldoublesize,&tp) ;
    }
    return stdldoublesize * 2;
}

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

/* Basic type subroutines */
int einitrcomplex(void)
{
    TYP tp;
    tp.type = bt_double;
    if (lastst == begin)
    {
        initassign(ecppfloat(),baseoffset,&tp) ;
        if (lastst == comma)
        {
            getsym();
            initassign(ecppfloat(),baseoffset+stddoublesize,&tp) ;
        } 
        else {
            ENODE *ep = makenode(en_fcon,0,0) ;
            ep->v.f = 0.0;
            initassign(ep,baseoffset+stddoublesize,&tp) ;
        }
        needpunc(end, 0);
    }
    else
    {
        ENODE *ep = makenode(en_fcon,0,0) ;
        initassign(ecppfloat(),baseoffset,&tp) ;
        ep->v.f = 0.0;
        initassign(ep,baseoffset+stddoublesize,&tp) ;
    }
    return stddoublesize * 2;
}

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

int einitfloat(void)
{
    TYP tp;
    tp.type = bt_float;

    initassign(ecppfloat(),baseoffset,&tp);
    return (stdfloatsize);
}

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

int einitlongdouble(void)
{
    TYP tp;
    tp.type = bt_longdouble;
    initassign(ecppfloat(),baseoffset,&tp);
    return (stdldoublesize);
}

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

int einitdouble(void)
{
    TYP tp;
    tp.type = bt_double;
    initassign(ecppfloat(),baseoffset,&tp);
    return (stddoublesize);
}

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

int einitchar(void)
{
    TYP tp ;
    tp.type = bt_char;
    initassign(ecppint(),baseoffset,&tp) ;
    return 1;
} 
int einitshort(void)
{
    TYP tp ;
    tp.type = bt_short;
    initassign(ecppint(),baseoffset,&tp) ;
    return stdshortsize;
}

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

int einituchar(void)
{
    TYP tp ;
    tp.type = bt_unsignedchar;
    initassign(ecppint(),baseoffset,&tp) ;
    return 1;
}

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

int einitushort(void)
{
    TYP tp ;
    tp.type = bt_unsignedshort;
    initassign(ecppint(),baseoffset,&tp) ;
    return stdshortsize;
}

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

int einitenum(void)
{
    TYP tp ;
    tp.type = bt_int;
    initassign(ecppint(),baseoffset,&tp) ;
    return stdenumsize;
}
int einitint(void)
{
    TYP tp ;
    tp.type = bt_int;
    initassign(ecppint(),baseoffset,&tp) ;
    return stdintsize;
}
int einitlong(void)
{
    TYP tp ;
    tp.type = bt_int;
    initassign(ecppint(),baseoffset,&tp) ;
    return stdlongsize;
}

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

int einituint(void)
{
    TYP tp ;
    tp.type = bt_unsigned;
    initassign(ecppint(),baseoffset,&tp) ;
    return stdintsize;
}
int einitulong(void)
{
    TYP tp ;
    tp.type = bt_unsigned;
    initassign(ecppint(),baseoffset,&tp) ;
    return stdlongsize;
}

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

int einitlonglong(void)
{
    TYP tp ;
    tp.type = bt_longlong;
    initassign(ecppint(),baseoffset,&tp) ;
    return stdlonglongsize;
}

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

int einitulonglong(void)
{
    TYP tp ;
    tp.type = bt_unsignedlonglong;
    initassign(ecppint(),baseoffset,&tp) ;
    return stdlonglongsize;
}

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

#ifdef CPLUSPLUSXXX
    int einitmemberptr(TYP *tp, SYM *btypequal)
    {
        TYP *t1;
        ENODE *node,  *node1;
        typequal = 0;
        t1 = asnop(&node, tp);
        if (t1->type != bt_memberptr)
        if (isintconst(node->nodetype) && node->v.i == 0)
        {
            agflush(4, 0);
            agflush(4, 0);
        }
        else
            generror(ERR_MEMBERPTRMISMATCH, 0, 0);
        else
        {
            ENODE *ep3 = makenode(en_nacon, locsp, 0);
            t1 = FindMemberPointer(tp, t1, &node, &node);
            if (!exactype(tp, t1, FALSE))
                generror(ERR_MEMBERPTRMISMATCH, 0, 0);
            while (castvalue(node))
                node = node->v.p[0];
            if (lvalue(node))
                node = node->v.p[0];
            node = makenode(en_moveblock, ep3, node);
            node->size = stdmemberptrsize;
            cppinitinsert(node);
        }

    }
#endif
    int einitref(TYP *tp)
    /*
     * init for reference variables
     */
    {
        SYM *sp;
        TYP *tp1;
        ENODE *node = 0,  *node1;
        allocated = TRUE;

        tp1 = exprnc(&node);
        if (exactype(locsp->tp, tp1, FALSE) || !(node1 = declRef(locsp, tp, tp1, 0,
            node)))
        {
            tp = tp->btp;
            if (matchreflvalue(0, locsp->tp, tp1))
            {
                while (castvalue(node))
                    node = node->v.p[0];
                if (lvalue(node))
                    node = node->v.p[0];
                {
                    TYP tp;
                    tp.type = bt_pointer;
                    initassign(node,baseoffset,&tp);
                }
            }
        }
        else
        {
            TYP tp;
            tp.type = bt_pointer;
            initassign(node1,baseoffset,&tp);
        }
        endinit();
        return stdaddrsize;
    }
void edopointer(int makextern)
{
    SYM *sp;
    ENODE *node = 0,  *node1;
    TYP *tp1;
    char *nm;
    int lst = lastst;
        {
            tp1 = exprnc(&node);
            opt4(&node);
            if (node && node->nodetype == en_labcon)
            {
                makelabel(node->v.i);
            }
            else if (node && isintconst(node->nodetype))
            {
                long temp;
                TYP tp;
                tp.type = bt_pointer;
                initassign(node,baseoffset,&tp);
                temp = node->v.i;
                if (temp || (tp1->type != bt_pointer) && tp1->type !=
                    bt_farpointer && tp1->type != bt_segpointer && (node->v.i))
                    generror(ERR_NONPORT, 0, 0);
            }
            else if (!node || (tp1->type != bt_pointer && tp1->type !=
                bt_farpointer && tp1->type != bt_segpointer && tp1->type !=
                bt_func && tp1->type != bt_ifunc && !tp1->val_flag))
                gensymerror(ERR_NOINIT, locsp->name);
            else
            {
                if (node->nodetype == en_nacon)
                {
                    TYP tp;
                    tp.type = bt_pointer;
                    initassign(node,baseoffset,&tp);
                    node->v.sp->tp->uflags |= UF_USED;
                }
                else
                {
                    {
                        TYP tp;
                        tp.type = bt_pointer;
                        initassign(node,baseoffset,&tp);
                    }
                }
            }
        }
}

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

int einitpointer(void)
{
    allocated = TRUE;
    edopointer(FALSE);
    endinit();
    return stdaddrsize; /* pointers are 4 bytes long */
}

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

int einitfarpointer(void)
{
    TYP tp;
    tp.type = bt_farpointer;
    initassign(ecppint(),baseoffset,&tp);
    return stdaddrsize + stdshortsize;
}

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

int einitpointerfunc(void)
{
    allocated = TRUE;
    edopointer(TRUE);
    endinit();
    return stdaddrsize; /* pointers are 4 bytes long */
}