rc.c

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

                if (lastst != end && lastst != kw_end)
                    generror(ERR_END_EXPECTED, 0, 0);
                getsym();

            }
            void parse_menu(RES_ID *id, RES_INFO *info, int extended)
            {
                struct menuitem *s = 0,  **p = &s;
                getsym();
                info->memflags |= MF_PURE;
                input_memflags(info);
                need_eol();
                input_secondary_characteristics(info);
                input_menulist(&p, extended);

                need_eol();
                define_menu(id, info, s);

            }
            void parse_rc(RES_ID *id, RES_INFO *info)
            {
                int done = FALSE;
                struct rcdata_item *r = 0,  **p = &r;
                getsym();
                info->memflags |= MF_PURE;
                input_memflags(info);
                need_eol();
                need_begin();
                while (!done)
                {
                    switch (lastst)
                    {
                        case sconst:
                            *p = define_rcdata_string(laststr, laststrlen);
                            getsym();
                            break;
                        case iconst:
                        case iuconst:
                        case cconst:
                            *p = define_rcdata_number(ival, FALSE);
                            getsym();
                            break;
                        case lconst:
                        case luconst:
                            *p = define_rcdata_number(ival, TRUE);
                            getsym();
                            break;
                        case eol:
                            getsym();
                            continue;
                        default:
                            done = TRUE;
                    }
                    if (!done)
                    {
                        skip_comma();
                        p = &(*p)->link;
                    }
                }
                need_end();
                define_rcdata(id, info, r);
            }
            void parse_messagetable(RES_ID *id, RES_INFO *info)
            {
                getsym();
                info->memflags |= MF_PURE;
                input_memflags(info);
                getfilename();
                need_eol();
                define_messagetable(id, info, laststr);
            }
            void parse_stringtable(RES_INFO *info)
            {
                getsym();
                info->memflags |= MF_PURE;
                input_memflags(info);
                need_eol();
                need_begin();
                while (is_number())
                {
                    int val = intexpr();
                    skip_comma();
                    if (lastst != sconst)
                        generror(ERR_STRING_EXPECTED, 0, 0);
                    define_stringtable(info, val, laststr);
                    getsym();
                    need_eol();
                }
                need_end();
            }
            void parse_versioninfo(RES_ID *id, RES_INFO *info)
            {
                int val, val1;
                int done = 0, did1 = 0;
                struct fixed_versioninfo *fixedverinfo = AllocateMemory(sizeof
                    (struct fixed_versioninfo));
                struct ver_info *verinfo = 0,  **verinfop = &verinfo;
                getsym();
                info->memflags = MF_PURE | MF_MOVEABLE;
                while (!done)
                {
                    val = val1 = 0;
                    switch (lastst)
                    {
                        case kw_fileversion:
                            getsym();
                            val = intexpr() << 16;
                            if (lastst == comma)
                            {
                                getsym();
                                val |= intexpr() &0xffff;
                                if (lastst == comma)
                                {
                                    getsym();
                                    val1 = intexpr() << 16;
                                    if (lastst == comma)
                                    {
                                        getsym();
                                        val1 |= intexpr() &0xffff;
                                    }
                                }
                            }
                            fixedverinfo->file_version_ms = val;
                            fixedverinfo->file_version_ls = val1;
                            break;
                        case kw_productversion:
                            getsym();
                            val = intexpr() << 16;
                            if (lastst == comma)
                            {
                                getsym();
                                val |= intexpr() &0xffff;
                                if (lastst == comma)
                                {
                                    getsym();
                                    val1 = intexpr() << 16;
                                    if (lastst == comma)
                                    {
                                        getsym();
                                        val1 |= intexpr() &0xffff;
                                    }
                                }
                            }
                            fixedverinfo->product_version_ms = val;
                            fixedverinfo->product_version_ls = val1;
                            break;
                        case kw_fileflagmask:
                            getsym();
                            fixedverinfo->file_flags_mask = intexpr();
                            break;
                        case kw_fileflags:
                            getsym();
                            fixedverinfo->file_flags = intexpr();
                            break;
                        case kw_fileos:
                            getsym();
                            fixedverinfo->file_os = intexpr();
                            break;
                        case kw_filetype:
                            getsym();
                            fixedverinfo->file_type = intexpr();
                            break;
                        case kw_filesubtype:
                            getsym();
                            fixedverinfo->file_subtype = intexpr();
                            break;
                        case eol:
                            getsym();
                            break;
                            //         case kw_filedate:
                            //            break ;
                        default:
                            if (!did1)
                                generror(ERR_FIXEDDATAEXPECTED, 0, 0);
                            done = 1;
                            break;
                    }
                    did1 = 1;
                }
                need_begin();
                if (lastst != kw_block)
                    generror(ERR_BLOCK_EXPECTED, 0, 0);
                while (lastst == kw_block)
                {
                    getsym();
                    if (lastst != sconst)
                        generror(ERR_INVALID_VERSION_INFO_TYPE, 0, 0);
                    if (!strcmp(laststr, "StringFileInfo"))
                    {
                        struct ver_stringinfo **current;
                        getsym();
                        need_eol();
                        need_begin();
                        if (lastst != kw_block)
                            generror(ERR_BLOCK_EXPECTED, 0, 0);
                        getsym();
                        *verinfop = AllocateMemory(sizeof(struct ver_info));
                        (*verinfop)->type = VERINFO_STRING;
                        input_string(&(*verinfop)->u.string.language);
                        need_eol();
                        current = &(*verinfop)->u.string.strings;
                        need_begin();
                        while (lastst == kw_value)
                        {
                            getsym();
                            if (lastst != sconst)
                                generror(ERR_STRING_EXPECTED, 0, 0);
                            *current = AllocateMemory(sizeof(struct
                                ver_stringinfo));
                            input_string(&(*current)->key);
                            if (lastst != comma)
                                generror(ERR_NEEDCHAR, ',', 0);
                            getsym();
                            (*current)->length = laststrlen;
                            if (lastst != sconst)
                                generror(ERR_STRING_EXPECTED, 0, 0);
                            (*current)->value = AllocateMemory(laststrlen *2+2);
                            for (val = 0; val < laststrlen; val++)
                                (*current)->value[val] = laststr[val];
                            getsym();
                            need_eol();
                            current = &(*current)->link;
                        } need_end();
                    }
                    else if (!strcmp(laststr, "VarFileInfo"))
                    {
                        struct ver_varinfo **current;
                        getsym();
                        need_eol();
                        need_begin();
                        *verinfop = AllocateMemory(sizeof(struct ver_info));
                        (*verinfop)->type = VERINFO_VAR;
                        current = &((*verinfop)->u.var.var);
                        while (lastst == kw_value)
                        {
                            struct ver_varlangchar **cur1;
                            *current = AllocateMemory(sizeof(struct ver_varinfo)
                                );
                            getsym();
                            input_string(&(*current)->key);
                            if (lastst != comma)
                                generror(ERR_NEEDCHAR, ',', 0);
                            getsym();
                            cur1 = &(*current)->intident;
                            while (TRUE)
                            {
                                *cur1 = AllocateMemory(sizeof(struct
                                    ver_varlangchar));
                                (*cur1)->language = intexpr();
                                if (lastst == comma)
                                {
                                    getsym();
                                    (*cur1)->charset = intexpr();
                                } if (lastst != comma)
                                    break;
                                getsym();
                                cur1 = &(*cur1)->link;
                            }
                            need_eol();
                            current = &(*current)->link;
                        }
                    }
                    else
                        generror(ERR_INVALID_VERSION_INFO_TYPE, 0, 0);


                    verinfop = &(*verinfop)->link;
                    need_end();

                }
                need_end();
                define_versioninfo(id, info, fixedverinfo, verinfo);
            }
            void parse_special(RES_ID *id, RES_INFO *info)
            {
                RES_ID type;
                incconst = TRUE;
                info->memflags |= MF_PURE;
                input_resid(&type);
                input_memflags(info);
                getfilename();
                need_eol();
                define_user_file(id, &type, info, laststr);
                incconst = FALSE;
            }
            void parse(char *name)
            {
                RES_ID id;
                RES_INFO info;
                infile = name;
                inputFile = fopen(name, "r");
                if (!inputFile)
                    fatal("file %s not found", name);

                getch();
                getsym();
                while (lastst != eof)
                {
                    while (lastst == eol)
                        getsym();
                    memset(&id, 0, sizeof(id));
                    if (lastst == ident || is_number())
                        input_resid(&id);
                    else
                    {
                        int st = lastst;
                        getsym();
                        if (lastst >= kw_accelerator && lastst < eol)
                        {
                            if (st >= kw_accelerator && st < eol)
                            {
                                char *s = namefromkw(st);
                                id.hasname = 1;
                                id.v.n.len = unicode_from_ascii(&id.v.n.name, s,
                                    strlen(s));
                            }
                            else
                                backup(st);
                        }
                        else
                            backup(st);
                    }
                    memset(&info, 0, sizeof(info));
                    info.memflags |= MF_MOVEABLE | MF_DISCARDABLE;
                    info.language = base_language;
                    switch (lastst)
                    {
                        case kw_accelerator:
                            parse_accelerator(&id, &info);
                            break;
                        case kw_bitmap:
                            parse_bitmap(&id, &info);
                            break;
                        case kw_cursor:
                            parse_cursor(&id, &info);
                            break;
                        case kw_dialog:
                            parse_dialog(&id, &info, FALSE);
                            break;
                        case kw_dialogex:
                            parse_dialog(&id, &info, TRUE);
                            break;
                        case kw_dlginclude:
                            parse_dlginclude(&id, &info);
                            break;
                        case kw_font:
                            parse_font(&id, &info);
                            break;
                        case kw_icon:
                            parse_icon(&id, &info);
                            break;
                        case kw_menu:
                            parse_menu(&id, &info, FALSE);
                            break;
                        case kw_menuex:
                            parse_menu(&id, &info, TRUE);
                            break;
                        case kw_rcdata:
                            parse_rc(&id, &info);
                            break;
                        case kw_versioninfo:
                            parse_versioninfo(&id, &info);
                            break;
                        case kw_messagetable:
                            parse_messagetable(&id, &info);
                            break;
                        case kw_stringtable:
                            parse_stringtable(&info);
                            break;
                        case kw_language:
                            getsym();
                            base_language = intexpr();
                            skip_comma();
                            base_language |= (intexpr() << 10);
                            need_eol();
                            break;
                        case kw_rcinclude:
                            doinclude(TRUE);
                            break;
                        case ident:
                            parse_special(&id, &info);
                            break;
                        default:
                            generror(ERR_UNKNOWN_RESOURCE_TYPE, 0, 0);
                            break;
                    }

                }
            }
            RES_DIR *parse_rc_file(char *filename)
            {
                char *cmd;

                parse(filename);

                if (fontdirs != NULL)
                    define_fontdirs();
                return resources;
            }