decl.c

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

{
    int tagsonly = FALSE;
    int tp;
    int flags = 0;
    SYM *typesp = 0,  *dc;
    int opened = FALSE;
    defaulttype = FALSE;

    while (lastst == kw_const || lastst == kw_volatile || lastst == kw_inline 
        || lastst == kw__intrinsic || lastst == kw_restrict || lastst ==
        kw__import || lastst == kw__export || (prm_cplusplus && (lastst ==
        kw_virtual || lastst == kw_static || lastst == kw_friend || lastst ==
        kw_explicit || lastst == kw_typename)))
    {
        switch (lastst)
        {
            case kw_typename:
                getsym();
                break;
            case kw__import:
                isimport = TRUE;
                importname = 0;
                getsym();
                if (lastst == openpa)
                {
                    getsym();
                    if (lastst == sconst)
                    {
                        importname = litlate(laststr);
                        getsym();
                        needpunc(closepa, 0);
                    }
                    else
                        generror(ERR_NEEDCHAR, '"', 0);
                }
                break;
            case kw__export:
                isexport = TRUE;
                getsym();
                break;
            case kw_const:
                flags |= DF_CONST;
                getsym();
                break;
            case kw_restrict:
                flags |= DF_RESTRICT;
                errlineno = lineno;
                generror(ERR_RESTRICTPTR, 0, 0);
                getsym();
                break;
            case kw_volatile:
                flags |= DF_VOL;
                getsym();
                break;
            case kw__intrinsic:
                flags |= DF_INTRINS;
                getsym();
                break;
            case kw_inline:
                cppflags |= PF_INLINE;
                getsym();
                break;
                case kw_virtual:
                    cppflags |= PF_VIRTUAL;
                    getsym();
                    break;
                case kw_static:
                    cppflags |= PF_STATIC;
                    getsym();
                    break;
                case kw_friend:
                    getsym();
                    aFriend = TRUE;
                    break;
                case kw_explicit:
                    getsym();
                    cppflags |= PF_EXPLICIT;
                    break;
        }
    }
    switch (lastst)
    {
        case kw_void:
            head = tail = maketype(bt_void, 0);
            getsym();
            break;
        case kw_bool:
            head = tail = maketype(bt_bool, 1);
            getsym();
            break;
        case kw_char:
            head = tail = maketype(bt_char, 1);
            getsym();
            break;
        case kw_short:
            getsym();
            tp = bt_short;
            if (lastst == kw_unsigned)
            {
                tp = bt_unsignedshort;
                getsym();
            }
            if (lastst == kw_int)
                getsym();
            head = tail = maketype(tp, stdshortsize);
            break;
        case kw_wchar_t:
            getsym();
            head = tail = maketype(bt_unsignedshort, stdwchar_tsize);
            break;
        case kw_int:
            getsym();
            head = tail = maketype(stdinttype, stdintsize);
            break;
        case kw___int64:
                    getsym();
                    #ifdef LONGS
                        head = tail = maketype(bt_longlong, stdlonglongsize);
                    #else 
                        generror(ERR_LONGLONG, 0, 0);
                    #endif 
            break;
        default:
            defaulttype = TRUE;
            head = tail = maketype(stdinttype, stdintsize);
            break;
        case kw_unsigned:
            getsym();
            switch (lastst)
            {
            case kw___int64:
                    getsym();
                    #ifdef LONGS
                        head = tail = maketype(bt_unsignedlonglong, stdlonglongsize);
                    #else 
                        generror(ERR_LONGLONG, 0, 0);
                    #endif 
                break ;
            case kw_char:
                getsym();
                head = tail = maketype(bt_unsignedchar, 1);
                break;
            case kw_short:
                getsym();
                if (lastst == kw_int)
                    getsym();
                head = tail = maketype(bt_unsignedshort, stdshortsize);
                break;
            case kw_long:
                getsym();
                if (prm_c99 && lastst == kw_long)
                {
                    getsym();
                    #ifdef LONGS
                        head = tail = maketype(bt_unsignedlonglong, stdlonglongsize);
                    #else 
                        generror(ERR_LONGLONG, 0, 0);
                    #endif 
                }
                else
                    head = tail = maketype(bt_unsignedlong, stdlongsize);
                if (lastst == kw_int)
                    getsym();
                break;
            case kw_int:
                getsym();
            default:
                head = tail = maketype(stdunstype, stdintsize);
                break;
            }
            break;
        case kw_signed:
            getsym();
            switch (lastst)
            {
            case kw_char:
                getsym();
                head = tail = maketype(bt_char, 1);
                break;
            case kw_short:
                getsym();
                if (lastst == kw_int)
                    getsym();
                head = tail = maketype(bt_short, stdshortsize);
                break;
            case kw_long:
                getsym();
                if (prm_c99 && lastst == kw_long)
                {
                    getsym();
                    #ifdef LONGS
                        head = tail = maketype(bt_longlong, stdlonglongsize);
                    #else 
                        generror(ERR_LONGLONG, 0, 0);
                    #endif 
                }
                else
                    head = tail = maketype(bt_long, stdlongsize);
                if (lastst == kw_int)
                    getsym();
                break;
            case kw_int:
                getsym();
            default:
                head = tail = maketype(bt_int, stdintsize);
                break;
            }
            break;
        case kw_class:
            if (prm_cplusplus)
            {
                getsym();
                if (aFriend)
                    table = gsyms;
                declstruct(table, bt_class, flags | DF_PRIVATE, cppflags);
                typequal = 0;
                break;
            }
        case id:
             /* no type declarator */
            defaulttype = TRUE;
            if ((typesp = typesearch(lastid)) && (typesp->storage_class ==
                sc_type || typesp->storage_class == sc_namespace))
            {
                getsym();
                if (prm_cplusplus)
                {
                    if (typesp && typesp->istemplate)
                        if (lastst == lt)
                            typesp = lookupTemplateType(typesp,cppflags);
                        else
                            if (lastst == classsel)
                                gensymerror(ERR_NEEDSPECIAL, typesp->name);
                    typesp = parsetype(typesp, TRUE);
                    if (lastst == openpa && typesp && declclass && typesp
                        ->mainsym == declclass->mainsym)
                    {
                        head = tail = maketype(bt_consplaceholder, stdaddrsize); 
                            // limited life
                        break;
                    }
                }
                    if (typesp && typesp->storage_class == sc_type)
                    {
                    //                                defaulttype = FALSE ;
                    typequal = 0;
                    head = tail = copytype(typesp->tp, flags);
                    }
                    else
                    {
                        head = tail = maketype(bt_int, stdintsize);
                        if (prm_c99)
                        {
                            errlineno = lineno;
                            generror(ERR_TYPENAMEEXP, 0, 0);
                        }

                    }
            }
            else
            {
                head = tail = maketype(bt_int, stdintsize);
                if (prm_c99)
                {
                    errlineno = lineno;
                    generror(ERR_TYPENAMEEXP, 0, 0);
                }
            }
            break;
        case kw_operator:
            head = tail = maketype(bt_int, stdintsize);
            break;
        case kw_float:
            getsym();
            if (lastst == kw__Complex)
            {
                getsym();
                head = tail = maketype(bt_fcomplex, stdfloatsize * 2);
            }
            else if (lastst == kw__Imaginary)
            {
                getsym();
                head = tail = maketype(bt_fimaginary, stdfloatsize);
            }
            else
                head = tail = maketype(bt_float, stdfloatsize);
            break;
        case kw_long:
            getsym();
            if (lastst == kw_double)
            {
                getsym();
                if (lastst == kw__Complex)
                {
                    getsym();
                    head = tail = maketype(bt_lrcomplex, stdldoublesize *2);
                }
                else if (lastst == kw__Imaginary)
                {
                    getsym();
                    head = tail = maketype(bt_lrimaginary, stdldoublesize);
                }
                else
                    head = tail = maketype(bt_longdouble, stdldoublesize);
                break;
            }
            if (lastst == kw_float)
            {
                getsym();
                if (lastst == kw__Complex)
                {
                    getsym();
                    head = tail = maketype(bt_rcomplex, stddoublesize * 2);
                }
                else if (lastst == kw__Imaginary)
                {
                    getsym();
                    head = tail = maketype(bt_rimaginary, stddoublesize);
                }
                else
                    head = tail = maketype(bt_double, stddoublesize);
                break;
            }
            if (prm_c99 && lastst == kw_long)
            {
                getsym();
                #ifdef LONGS
                    tp = bt_longlong;
                #else 
                    generror(ERR_LONGLONG, 0, 0);
                    tp = bt_int;
                #endif 
            }
            else
                tp = bt_long;

            if (lastst == kw_unsigned)
            {
                #ifdef LONGS
                    if (tp == bt_longlong)
                        tp = bt_unsignedlonglong;
                    else
                #endif 
                    tp = bt_unsignedlong;
                getsym();
            }
            if (lastst == kw_int)
                getsym();
            #ifdef LONGS
                if (tp == bt_longlong || tp == bt_unsignedlonglong)
                    head = tail = maketype(tp, stdlonglongsize);
                else
            #endif 
                head = tail = maketype(tp, stdintsize);
            break;
        case kw_double:
            getsym();
            if (lastst == kw__Complex)
            {
                getsym();
                head = tail = maketype(bt_rcomplex, stddoublesize * 2);
            }
            else if (lastst == kw__Imaginary)
            {
                getsym();
                head = tail = maketype(bt_rimaginary, stddoublesize);
            }
            else
                head = tail = maketype(bt_double, stddoublesize);
            break;
        case kw_enum:
            getsym();
            declenum(table, cppflags);
            break;
        case kw_struct:
            getsym();
            declstruct(table, bt_struct, flags | DF_PUBLIC, cppflags);
            typequal = 0;
            break;
        case kw_union:
            getsym();
            declstruct(table, bt_union, flags, cppflags);
            typequal = 0;
            break;
        case kw_typeof:
            getsym();
            if (lastst == openpa)
            {
                opened = TRUE;
                getsym();