cvtres.c

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

    add = 4-(*length &3);

    d = (BINDATA*)AllocateMemory(sizeof *d);
    d->length = add;
    d->data = AllocateMemory(add);
    memset(d->data, 0, add);

    d->link = NULL;
    **ppp = d;
    *ppp = &(**ppp)->link;

    *length += add;
}

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

static BINDATA *from_resid(RES_ID id, int be)
{
    BINDATA *d = AllocateMemory(sizeof(*d));
    if (!id.hasname)
    {
        if (!id.v.id)
        {

            d->length = 2;
            d->data = AllocateMemory(4);
            put_16(be, 0, d->data);
        }
        else
        {
            d->length = 4;
            d->data = AllocateMemory(4);
            put_16(be, 0xffff, d->data);
            put_16(be, id.v.id, d->data + 2);
        }
    }
    else
    {
        int i;

        d->length = id.v.n.len * 2+2;
        d->data = AllocateMemory(d->length);
        for (i = 0; i < id.v.n.len + 1; i++)
            put_16(be, id.v.n.name[i], d->data + i * 2);
    }

    d->link = NULL;

    return d;
}

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

static BINDATA *from_string(CHARACTER *str, int be)
{
    int len, i;
    BINDATA *d;
    CHARACTER *s;

    len = 1;

    if (str)
        for (s = str;  *s != 0; s++)
            ++len;

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

    if (str)
        for (s = str, i = 0; i < len; s++, i++)
            put_16(be,  *s, d->data + i * 2);
        else
            put_16(be, 0, d->data);

    d->link = NULL;

    return d;
}

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

static BINDATA *from_string_len(CHARACTER *str, int be, int len)
{
    int i;
    BINDATA *d;
    CHARACTER *s;

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

    if (str)
        for (s = str, i = 0; i < len; s++, i++)
            put_16(be,  *s, d->data + i * 2);
        else
            put_16(be, 0, d->data);

    d->link = NULL;

    return d;
}

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

static BINDATA *ascii_to_string(char *s, int be)
{
    size_t len, i;
    BINDATA *d = AllocateMemory(sizeof(BINDATA));

    len = strlen(s);

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

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

    d->link = NULL;

    return d;
}

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

int extended_dialog(struct dialog *dialog)
{
    const struct dialog_control *c;

    if (dialog->ex != NULL)
        return 1;

    for (c = dialog->controls; c != NULL; c = c->link)
        if (c->data != NULL || c->help != 0)
            return 1;

    return 0;
} 

static int extended_menuitems(struct menuitem *menuitems)
{
    const struct menuitem *mi;

    for (mi = menuitems; mi != NULL; mi = mi->link)
    {
        if (mi->help != 0 || mi->state != 0)
            return 1;
        if (mi->popup != NULL && mi->id != 0)
            return 1;
        if ((mi->type &~(MI_CHECKED | MI_GRAYED | MI_HELP | MI_INACTIVE |
            MI_MENUBARBREAK | MI_MENUBREAK)) != 0)
            return 1;
        if (mi->popup != NULL)
        {
            if (extended_menuitems(mi->popup))
                return 1;
        } 
    }

    return 0;
}

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

int extended_menu(struct menu *menu)
{
    return extended_menuitems(menu->items);
} 


static BINDATA *from_rcdata(struct rcdata_item *items, int be)
{
    BINDATA *first = NULL,  **pp = &first;
    const struct rcdata_item *ri;

    for (ri = items; ri != NULL; ri = ri->link)
    {
        BINDATA *d = AllocateMemory(sizeof(*d));
        switch (ri->type)
        {
            default:
                fatal("invalid RCDATA sect");

            case RCDATA_WORD:
                d->length = 2;
                d->data = AllocateMemory(2);
                put_16(be, ri->u.word, d->data);
                break;

            case RCDATA_DWORD:
                d->length = 4;
                d->data = AllocateMemory(4);
                put_32(be, ri->u.dword, d->data);
                break;

            case RCDATA_STRING:
                d->length = ri->u.string.length;
                d->data = (unsigned char*)ri->u.string.s;
                break;

            case RCDATA_WSTRING:
                {
                    unsigned long i;

                    d->length = ri->u.wstring.length *2;
                    d->data = AllocateMemory(d->length);
                    for (i = 0; i < ri->u.wstring.length; i++)
                        put_16(be, ri->u.wstring.w[i], d->data + i * 2);
                    break;
                }

            case RCDATA_BUFFER:
                d->length = ri->u.buffer.length;
                d->data = (unsigned char*)ri->u.buffer.data;
                break;
        }

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

    return first;
}

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

static BINDATA *from_accelerator(struct accelerator *acc, int be)
{
    BINDATA *first = NULL,  **pp = &first;
    const struct accelerator *a;
    for (a = acc; a != NULL; a = a->link)
    {
        BINDATA *d = AllocateMemory(sizeof(BINDATA));
        d->length = 8;
        d->data = AllocateMemory(8);

        put_16(be, a->flags | (a->link != NULL ? 0 : ACC_LAST), d->data);
        put_16(be, a->key, d->data + 2);
        put_16(be, a->id, d->data + 4);
        put_16(be, 0, d->data + 6);

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

    return first;
}

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

static BINDATA *from_cursor(struct cursor *c, int be)
{
    BINDATA *d = AllocateMemory(sizeof(BINDATA));
    d->length = 4;
    d->data = AllocateMemory(4);

    put_16(be, c->xhotspot, d->data);
    put_16(be, c->yhotspot, d->data + 2);

    d->link = AllocateMemory(sizeof *d);
    d->link->length = c->length;
    d->link->data = (unsigned char*)c->data;
    d->link->link = NULL;

    return d;
} 

static BINDATA *from_dialog(struct dialog *dialog, int be)
{
    int dialogex;
    BINDATA *first = AllocateMemory(sizeof(BINDATA)),  **pp = &first->link;
    unsigned long length;
    int off, c;
    struct dialog_control *dc;

    dialogex = extended_dialog(dialog);

    first->length = dialogex ? 26 : 18;
    first->data = AllocateMemory(first->length);
    first->link = NULL;

    length = first->length;

    if (!dialogex)
    {
        put_32(be, dialog->style, first->data);
        put_32(be, dialog->exstyle, first->data + 4);
        off = 8;
    } 
    else
    {
        put_16(be, 0xffff, first->data);
        put_16(be, 1, first->data + 2);
        if (dialog->ex == NULL)
            put_32(be, 0, first->data + 4);
        else
            put_32(be, dialog->ex->help, first->data + 4);
        put_32(be, dialog->exstyle, first->data + 8);
        put_32(be, dialog->style, first->data + 12);
        off = 16;
    }

    put_16(be, dialog->x, first->data + off + 2);
    put_16(be, dialog->y, first->data + off + 4);
    put_16(be, dialog->width, first->data + off + 6);
    put_16(be, dialog->height, first->data + off + 8);

    *pp = from_resid(dialog->menu, be);
    length += (*pp)->length;
    pp = &(*pp)->link;

    *pp = from_resid(dialog->class , be);
    length += (*pp)->length;
    pp = &(*pp)->link;

    *pp = from_string(dialog->caption, be);
    length += (*pp)->length;
    pp = &(*pp)->link;

    if ((dialog->style &DS_SETFONT) != 0)
    {
            BINDATA *d = AllocateMemory(sizeof(BINDATA));

            d->length = dialogex ? 6 : 2;
            d->data = AllocateMemory(d->length);

            length += d->length;

            put_16(be, dialog->pointsize, d->data);

            if (dialogex)
            if (dialog->ex == NULL)
            {
                    put_16(be, 0, d->data + 2);
                    put_16(be, 0, d->data + 4);
            }
            else
            {
                    put_16(be, dialog->ex->weight, d->data + 2);
                    put_16(be, dialog->ex->italic, d->data + 4);
            }

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

            *pp = from_string(dialog->font, be);
            length += (*pp)->length;
            pp = &(*pp)->link;
    }

    c = 0;
    for (dc = dialog->controls; dc != NULL; dc = dc->link)
    {
        BINDATA *d = AllocateMemory(sizeof(BINDATA));
        int dcoff;

        ++c;

        align(&pp, &length);

        d->length = dialogex ? 22 : 18;
        d->data = AllocateMemory(d->length);

        length += d->length;

        if (!dialogex)
        {
            put_32(be, dc->style, d->data);
            put_32(be, dc->exstyle, d->data + 4);
            dcoff = 8;
        }
        else
        {
            put_32(be, dc->help, d->data);
            put_32(be, dc->exstyle, d->data + 4);
            put_32(be, dc->style, d->data + 8);
            dcoff = 12;
        }

        put_16(be, dc->x, d->data + dcoff);
        put_16(be, dc->y, d->data + dcoff + 2);
        put_16(be, dc->width, d->data + dcoff + 4);
        put_16(be, dc->height, d->data + dcoff + 6);
        put_16(be, dc->id, d->data + dcoff + 8);

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

        *pp = from_resid(dc->class , be);
        length += (*pp)->length;
        pp = &(*pp)->link;

        *pp = from_resid(dc->text, be);
        length += (*pp)->length;
        pp = &(*pp)->link;

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

        length += 2;

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

        if (dc->data == NULL)
            put_16(be, 0, d->data);
        else
        {
                unsigned long i;

                align(&pp, &length);

                *pp = from_rcdata(dc->data, be);
                i = 0;
                while (*pp != NULL)
                {
                        i += (*pp)->length;
                        pp = &(*pp)->link;
                }

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

                length += i;
        }
    }

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

    return first;
}

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

static BINDATA *from_fontdir(struct fontdir *fontdirs, int be)
{
    BINDATA *first = AllocateMemory(sizeof(BINDATA)),  **pp = &first->link;
    int c;
    const struct fontdir *fd;

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

    c = 0;
    for (fd = fontdirs; fd != NULL; fd = fd->link)
    {
        BINDATA *d;

        ++c;

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

        put_16(be, fd->index, d->data);

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

        d = AllocateMemory(sizeof *d);
        d->length = fd->length;
        d->data = (unsigned char*)fd->data;

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

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

    return first;
}

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

static BINDATA *from_generic(unsigned long length, unsigned char *data)
{
    BINDATA *d = AllocateMemory(sizeof(BINDATA));
    d->length = length;
    d->data = (unsigned char*)data;

    d->link = NULL;

    return d;
}

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

static BINDATA *from_group_cursor(struct group_cursor *gcs, int be)
{
    BINDATA *first = AllocateMemory(sizeof(BINDATA)),  **pp = &first->link;
    const struct group_cursor *gc;
    int c;

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

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

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

        ++c;

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

        put_16(be, gc->width, d->data);
        put_16(be, gc->height, d->data + 2);