cvtres.c

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

        put_16(be, gc->planes, d->data + 4);
        put_16(be, gc->bits, d->data + 6);
        put_32(be, gc->bytes, d->data + 8);
        put_16(be, gc->index, d->data + 12);

        d->link = NULL;
        *pp = d;
        pp = &d->link;
    } 

    put_16(be, c, first->data + 4);

    return first;
}

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

static BINDATA *from_group_icon(struct group_icon *group_icons, int be)
{
    BINDATA *first = AllocateMemory(sizeof(BINDATA)),  **pp = &first->link;
    int c;
    const struct group_icon *gi;

    first->length = 6;
    first->data = AllocateMemory(6);
    first->link = NULL;

    put_16(be, 0, first->data);
    put_16(be, 1, first->data + 2);

    c = 0;
    for (gi = group_icons; gi != NULL; gi = gi->link)
    {
        BINDATA *d = AllocateMemory(sizeof(BINDATA));

        ++c;

        d->length = 14;
        d->data = AllocateMemory(14);

        d->data[0] = gi->width;
        d->data[1] = gi->height;
        d->data[2] = gi->colors;
        d->data[3] = 0;
        put_16(be, gi->planes, d->data + 4);
        put_16(be, gi->bits, d->data + 6);
        put_32(be, gi->bytes, d->data + 8);
        put_16(be, gi->index, d->data + 12);

        d->link = NULL;
        *pp = d;
        pp = &d->link;
    } 

    put_16(be, c, first->data + 4);

    return first;
}

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

static BINDATA *from_menuitems(struct menuitem *items, int be)
{
    BINDATA *first = NULL,  **pp = &first;
    const struct menuitem *mi;

    for (mi = items; mi != NULL; mi = mi->link)
    {
        BINDATA *d = AllocateMemory(sizeof(BINDATA));
        int flags;

        d->length = mi->popup == NULL ? 4 : 2;
        d->data = AllocateMemory(d->length);

        flags = mi->flags;
        if (mi->link == NULL)
            flags |= MI_ENDMENU;
        if (mi->popup != NULL)
            flags |= MI_POPUP;

        put_16(be, flags, d->data);

        if (mi->popup == NULL)
            put_16(be, mi->id, d->data + 2);

        *pp = d;
        pp = &d->link;

        *pp = from_string(mi->text, be);
        pp = &(*pp)->link;

        if (mi->popup != NULL)
        {
            *pp = from_menuitems(mi->popup, be);
            while (*pp != NULL)
                pp = &(*pp)->link;
        } 
    }

    *pp = NULL;
    return first;
}

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

static BINDATA *from_menuexitems(struct menuitem *items, int be)
{
    BINDATA *first = NULL,  **pp = &first;
    unsigned long length = 0;
    const struct menuitem *mi;

    for (mi = items; mi != NULL; mi = mi->link)
    {
        BINDATA *d = AllocateMemory(sizeof(BINDATA));
        int flags;

        align(&pp, &length);

        d->length = 12;
        d->data = AllocateMemory(12);

        length += 12;

        put_32(be, mi->type, d->data);
        put_32(be, mi->state, d->data + 4);
        put_16(be, mi->id, d->data + 8);

        flags = 0;
        if (mi->link == NULL)
            flags |= 0x80;
        if (mi->popup != NULL)
            flags |= 1;
        put_16(be, flags, d->data + 10);

        *pp = d;
        pp = &d->link;

        *pp = from_string(mi->text, be);
        length += (*pp)->length;
        pp = &(*pp)->link;

        if (mi->popup != NULL)
        {
            align(&pp, &length);

            d = AllocateMemory(sizeof *d);
            d->length = 4;
            d->data = AllocateMemory(4);

            put_32(be, mi->help, d->data);

            *pp = d;
            pp = &d->link;

            *pp = from_menuexitems(mi->popup, be);
            while (*pp != NULL)
            {
                length += (*pp)->length;
                pp = &(*pp)->link;
            } 
        }
    }

    *pp = NULL;
    return first;
}

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

static BINDATA *from_menu(struct menu *menu, int be)
{
    int menuex;
    BINDATA *d = AllocateMemory(sizeof(BINDATA));

    menuex = extended_menu(menu);

    d->length = menuex ? 8 : 4;
    d->data = AllocateMemory(d->length);

    if (!menuex)
    {
        put_16(be, 0, d->data);
        put_16(be, 0, d->data + 2);

        d->link = from_menuitems(menu->items, be);
    } 
    else
    {
        put_16(be, 1, d->data);
        put_16(be, 4, d->data + 2);
        put_32(be, menu->help, d->data + 4);

        d->link = from_menuexitems(menu->items, be);
    }

    return d;
}

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


static BINDATA *from_stringtable(struct stringtable *st, int be)
{
    BINDATA *first = NULL,  **pp = &first;
    int i;

    for (i = 0; i < 16; i++)
    {
        int slen, j;
        BINDATA *d = AllocateMemory(sizeof(*d));
        CHARACTER *s;

        slen = st->strings[i].length;
        s = st->strings[i].string;

        d->length = 2+slen * 2;
        d->data = AllocateMemory(d->length);

        put_16(be, slen, d->data);

        for (j = 0; j < slen; j++)
            put_16(be, s[j], d->data + 2+j * 2);

        d->link = NULL;
        *pp = d;
        pp = &d->link;
    } 

    return first;
}

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

static BINDATA *from_versioninfo(struct versioninfo *versioninfo, int be)
{
    BINDATA *first = AllocateMemory(sizeof(BINDATA)),  **pp = &first->link;
    unsigned long length;
    struct ver_info *vi;

    first->length = 6;
    first->data = AllocateMemory(6);

    length = 6;

    if (versioninfo->fixed == NULL)
        put_16(be, 0, first->data + 2);
    else
        put_16(be, 52, first->data + 2);

    put_16(be, 0, first->data + 4);

    *pp = ascii_to_string("VS_VERSION_INFO", be);
    length += (*pp)->length;
    pp = &(*pp)->link;

    align(&pp, &length);

    if (versioninfo->fixed)
    {
        const struct fixed_versioninfo *fi;
        BINDATA *d = AllocateMemory(sizeof(BINDATA));

        d->length = 52;
        d->data = AllocateMemory(52);

        length += 52;

        fi = versioninfo->fixed;

        put_32(be, 0xfeef04bd, d->data);
        put_32(be, 0x10000, d->data + 4);
        put_32(be, fi->file_version_ms, d->data + 8);
        put_32(be, fi->file_version_ls, d->data + 12);
        put_32(be, fi->product_version_ms, d->data + 16);
        put_32(be, fi->product_version_ls, d->data + 20);
        put_32(be, fi->file_flags_mask, d->data + 24);
        put_32(be, fi->file_flags, d->data + 28);
        put_32(be, fi->file_os, d->data + 32);
        put_32(be, fi->file_type, d->data + 36);
        put_32(be, fi->file_subtype, d->data + 40);
        put_32(be, fi->file_date_ms, d->data + 44);
        put_32(be, fi->file_date_ls, d->data + 48);

        d->link = NULL;
        *pp = d;
        pp = &d->link;
    } 

    for (vi = versioninfo->var; vi != NULL; vi = vi->link)
    {
        BINDATA *vid = AllocateMemory(sizeof(BINDATA));
        unsigned long vilen;

        align(&pp, &length);

        vid->length = 6;
        vid->data = AllocateMemory(6);

        length += 6;
        vilen = 6;

        put_16(be, 0, vid->data + 2);
        put_16(be, 0, vid->data + 4);

        *pp = vid;
        pp = &vid->link;

        switch (vi->type)
        {
            default:
                fatal("invalid var version type");

            case VERINFO_STRING:
                {
                    unsigned long hold, vslen;
                    BINDATA *vsd = AllocateMemory(sizeof(BINDATA));
                    const struct ver_stringinfo *vs;

                    *pp = ascii_to_string("StringFileInfo", be);
                    length += (*pp)->length;
                    vilen += (*pp)->length;
                    pp = &(*pp)->link;

                    hold = length;
                    align(&pp, &length);
                    vilen += length - hold;

                    vsd->length = 6;
                    vsd->data = AllocateMemory(6);

                    length += 6;
                    vilen += 6;
                    vslen = 6;

                    put_16(be, 0, vsd->data + 2);
                    put_16(be, 0, vsd->data + 4);

                    *pp = vsd;
                    pp = &vsd->link;

                    *pp = from_string(vi->u.string.language, be);
                    length += (*pp)->length;
                    vilen += (*pp)->length;
                    vslen += (*pp)->length;
                    pp = &(*pp)->link;

                    for (vs = vi->u.string.strings; vs != NULL; vs = vs->link)
                    {
                        BINDATA *vssd;
                        unsigned long vsslen;

                        hold = length;
                        align(&pp, &length);
                        vilen += length - hold;
                        vslen += length - hold;

                        vssd = AllocateMemory(sizeof *vssd);
                        vssd->length = 6;
                        vssd->data = AllocateMemory(6);

                        length += 6;
                        vilen += 6;
                        vslen += 6;
                        vsslen = 6;

                        put_16(be, vs->length, vssd->data + 2);
                        put_16(be, 1, vssd->data + 4);

                        *pp = vssd;
                        pp = &vssd->link;

                        *pp = from_string(vs->key, be);
                        length += (*pp)->length;
                        vilen += (*pp)->length;
                        vslen += (*pp)->length;
                        vsslen += (*pp)->length;
                        pp = &(*pp)->link;

                        hold = length;
                        align(&pp, &length);
                        vilen += length - hold;
                        vslen += length - hold;
                        vsslen += length - hold;

                        *pp = from_string_len(vs->value, be, vs->length);
                        length += (*pp)->length;
                        vilen += (*pp)->length;
                        vslen += (*pp)->length;
                        vsslen += (*pp)->length;
                        pp = &(*pp)->link;

                        put_16(be, vsslen, vssd->data);
                    }

                    put_16(be, vslen, vsd->data);

                    break;
                }

            case VERINFO_VAR:
                {
                    unsigned long hold;
                    const struct ver_varinfo *vv;

                    *pp = ascii_to_string("VarFileInfo", be);
                    length += (*pp)->length;
                    vilen += (*pp)->length;
                    pp = &(*pp)->link;

                    hold = length;
                    align(&pp, &length);
                    vilen += length - hold;


                    for (vv = vi->u.var.var; vv != NULL; vv = vv->link)
                    {
                        unsigned long vvlen, vvvlen;
                        BINDATA *vvd = AllocateMemory(sizeof(BINDATA));
                        const struct ver_varlangchar *vlc;

                        vvd->length = vvlen = 6;
                        vvd->data = AllocateMemory(6);

                        length += 6;
                        vilen += 6;

                        put_16(be, 0, vvd->data + 4);

                        *pp = vvd;
                        pp = &vvd->link;

                        *pp = from_string(vv->key, be);
                        length += (*pp)->length;
                        vilen += (*pp)->length;
                        vvlen += (*pp)->length;
                        pp = &(*pp)->link;

                        hold = length;
                        align(&pp, &length);
                        vilen += length - hold;
                        vvlen += length - hold;

                        vvvlen = 0;

                        for (vlc = vv->intident; vlc != NULL; vlc = vlc->link)
                        {
                            BINDATA *vvsd = AllocateMemory(sizeof(BINDATA));

                            vvsd->length = 4;
                            vvsd->data = AllocateMemory(4);

                            length += 4;
                            vilen += 4;
                            vvlen += 4;
                            vvvlen += 4;

                            put_16(be, vlc->language, vvsd->data);
                            put_16(be, vlc->charset, vvsd->data + 2);

                            vvsd->link = NULL;
                            *pp = vvsd;
                            pp = &vvsd->link;
                        }

                        put_16(be, vvlen, vvd->data);
                        put_16(be, vvvlen, vvd->data + 2);

                    }
                }
                break;
        }

        put_16(be, vilen, vid->data);
    }

    put_16(be, length, first->data);
    *pp = NULL;
    return first;
}

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

BINDATA *convert_from_internal(RES_RES *res, int be)
{
    switch (res->type)
    {
        default:
            abort();
        case RST_BITMAP:
        case RST_FONT:
        case RST_ICON:
        case RST_MESSAGETABLE:
        case RST_DLGINCLUDE:
            return from_generic(res->u.data.length, res->u.data.data);
        case RST_ACCELERATOR:
            return from_accelerator(res->u.acc, be);
        case RST_CURSOR:
            return from_cursor(res->u.cursor, be);
        case RST_GROUP_CURSOR:
            return from_group_cursor(res->u.group_cursor, be);
        case RST_DIALOG:
            return from_dialog(res->u.dialog, be);
        case RST_FONTDIR:
            return from_fontdir(res->u.fontdir, be);
        case RST_GROUP_ICON:
            return from_group_icon(res->u.group_icon, be);
        case RST_MENU:
            return from_menu(res->u.menu, be);
        case RST_RCDATA:
            return from_rcdata(res->u.rcdata, be);
        case RST_STRINGTABLE:
            return from_stringtable(res->u.stringtable, be);
        case RST_USERDATA:
            return from_rcdata(res->u.rcdata, be);
        case RST_VERSIONINFO:
            return from_versioninfo(res->u.versioninfo, be);
    }
}