cvtres.c

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

/* 
Copyright 1997, 1998 Free Software Foundation, Inc.
Written by Ian Lance Taylor, Cygnus Support.

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.  

------
DAL 2001-2003 This file extensively modified and only resembles
the original

You may contact the author at:

mailto::[e-mail]

or by snail mail at:

David Lindauer
850 Washburn Ave Apt 99
Louisville, KY 40222
 */
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <time.h>
#include "cmdline.h"
#include "umem.h"
#include "xrc.h"

static int get_16(int be, unsigned char *s)
{
    if (be)
    {
        return (*s << 8) + *(s + 1);
    }
    else
    {
        return *(short*)s;
    }
}

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

static long get_32(int be, unsigned char *s)
{
    if (be)
    {
        return (*s << 24) + (*(s + 1) << 16) + (*(s + 2) << 8) + *(s + 3);
    }
    else
    {
        return *(long*)s;
    }
}

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

static void checksize(int left, int size)
{
    if (left < size)
        fatal("malformed resource in RES file, exiting");
}

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

#ifdef XXXXX
    static CHARACTER *to_string(unsigned char *data, int length, int be, int
        *retlen)
    {
        int c, i;
        CHARACTER *ret;

        c = 0;
        while (1)
        {
            checksize(length, (c + 1) *2);
            if (get_16(be, data + c * 2) == 0)
                break;
            ++c;
        }

        ret = (CHARACTER*)AllocateMemory((c + 1) *sizeof(CHARACTER));

        for (i = 0; i < c; i++)
            ret[i] = get_16(be, data + i * 2);
        ret[i] = 0;

        if (retlen != NULL)
            *retlen = c;

        return ret;
    }

    static int to_resid(RES_ID *id, unsigned char *data, int length, int be)
    {
        int first;

        checksize(length, 2);

        first = get_16(be, data);
        if (first == 0xffff)
        {
            checksize(length, 4);
            id->hasname = FALSE;
            id->v.id = get_16(be, data + 2);
            return 4;
        }
        else
        {
            id->hasname = TRUE;
            id->v.n.name = to_string(data, length, be, &id->v.n.len);
            return id->v.n.len *2+2;
        }
    }
    static RES_RES *to_accelerators(unsigned char *data, int length, int be)
    {
        RES_RES *r = AllocateMemory(sizeof(RES_RES));
        struct accelerator *first = NULL,  **pp = &first;

        r->type = RST_ACCELERATOR;

        while (1)
        {
            struct accelerator *a;

            checksize(length, 8);

            a = AllocateMemory(sizeof(*a));

            a->flags = get_16(be, data);
            a->key = get_16(be, data + 2);
            a->id = get_16(be, data + 4);

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

            if ((a->flags &ACC_LAST) != 0)
                break;

            data += 8;
            length -= 8;
        } 

        r->u.acc = first;

        return r;
    }
    static RES_RES *to_cursor(unsigned char *data, int length, int be)
    {
        RES_RES *r = AllocateMemory(sizeof(RES_RES));
        struct cursor *c = AllocateMemory(sizeof(struct cursor));

        checksize(length, 4);

        c->xhotspot = get_16(be, data);
        c->yhotspot = get_16(be, data + 2);
        c->length = length - 4;
        c->data = data + 4;

        r->type = RST_CURSOR;
        r->u.cursor = c;

        return r;
    }
    static RES_RES *to_generic(enum res_type type, unsigned char *data, int
        length)
    {

        RES_RES *r = AllocateMemory(sizeof(RES_RES));
        r->type = type;
        r->u.data.data = data;
        r->u.data.length = length;

        return r;
    } 


    static RES_RES *to_dialog(unsigned char *data, int length, int be)
    {
        int version;
        struct dialog *d = AllocateMemory(sizeof(struct dialog));
        int c, sublen, off, i;
        struct dialog_control **pp;
        RES_RES *r = AllocateMemory(sizeof(RES_RES));

        r->type = RST_DIALOG;
        r->u.dialog = d;

        checksize(length, 18);

        version = get_16(be, data);
        if (version != 0xffff)
        {
            d->ex = NULL;
            d->style = get_32(be, data);
            d->exstyle = get_32(be, data + 4);
            off = 8;
        } 
        else
        {
            int signature;

            signature = get_16(be, data + 2);
            if (signature != 1)
                fatal("unexpected dialog signature %d", signature);

            d->ex = (struct dialog_ex*)AllocateMemory(sizeof(struct dialog_ex));
            d->ex->help = get_32(be, data + 4);
            d->exstyle = get_32(be, data + 8);
            d->style = get_32(be, data + 12);
            off = 16;
        }
        checksize(length, off + 10);

        c = get_16(be, data + off);
        d->x = get_16(be, data + off + 2);
        d->y = get_16(be, data + off + 4);
        d->width = get_16(be, data + off + 6);
        d->height = get_16(be, data + off + 8);

        off += 10;

        sublen = to_resid(&d->menu, data + off, length - off, be);
        off += sublen;

        sublen = to_resid(&d->class , data + off, length - off, be);
        off += sublen;

        d->caption = to_string(data + off, length - off, be, &sublen);
        off += sublen * 2+2;

        if (!(d->style &DS_SETFONT))
        {
                d->pointsize = 0;
                d->font = NULL;
                if (d->ex)
                {
                        d->ex->weight = 0;
                        d->ex->italic = 0;
                } 
        }
        else
        {
            checksize(length, off + 2);

            d->pointsize = get_16(be, data + off);
            off += 2;

            if (d->ex)
            {
                checksize(length, off + 4);
                d->ex->weight = get_16(be, data + off);
                d->ex->italic = get_16(be, data + off + 2);
                off += 4;
            }

            d->font = to_string(data + off, length - off, be, &sublen);
            off += sublen * 2+2;
        }

        d->controls = NULL;
        pp = &d->controls;

        for (i = 0; i < c; i++)
        {
            struct dialog_control *dc = AllocateMemory(sizeof(struct
                dialog_control));
            int datalen;

            off = (off + 3) &~3;

            if (!d->ex)
            {
                checksize(length, off + 8);

                dc->style = get_32(be, data + off);
                dc->exstyle = get_32(be, data + off + 4);
                dc->help = 0;
                off += 8;
            } 
            else
            {
                checksize(length, off + 12);
                dc->help = get_32(be, data + off);
                dc->exstyle = get_32(be, data + off + 4);
                dc->style = get_32(be, data + off + 18);
                off += 12;
            }

            checksize(length, off + 10);

            dc->x = get_16(be, data + off);
            dc->y = get_16(be, data + off + 2);
            dc->width = get_16(be, data + off + 4);
            dc->height = get_16(be, data + off + 6);
            dc->id = get_16(be, data + off + 8);

            off += 10;

            sublen = to_resid(&dc->class , data + off, length - off, be);
            off += sublen;

            sublen = to_resid(&dc->text, data + off, length - off, be);
            off += sublen;

            checksize(length, off + 2);

            datalen = get_16(be, data + off);
            off += 2;

            dc->data = NULL;
            if (datalen)
            {
                    off = (off + 3) &~3;

                    checksize(length, off + datalen);
                    dc->data = AllocateMemory(sizeof(struct rcdata_item));
                    dc->data->link = NULL;
                    dc->data->type = RCDATA_BUFFER;
                    dc->data->u.buffer.length = datalen;
                    dc->data->u.buffer.data = data + off;

                    off += datalen;
            }

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


        return r;
    }
    static RES_RES *to_fontdir(unsigned char *data, int length, int be)
    {
        RES_RES *r = AllocateMemory(sizeof(RES_RES));
        int c, i;
        struct fontdir *first = NULL,  **pp = &first;

        r->type = RST_FONTDIR;

        checksize(length, 2);

        c = get_16(be, data);

        for (i = 0; i < c; i++)
        {
            struct fontdir *fd = AllocateMemory(sizeof(struct fontdir));
            int off;

            checksize(length, 56);

            fd->index = get_16(be, data);

            off = 56;

            while (off < length && data[off] != '\0')
                ++off;
            ++off;

            while (off < length && data[off] != '\0')
                ++off;
            checksize(length, off);
            ++off;

            fd->length = off;
            fd->data = data;

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

            data += off;
            length -= off;
        } 

        r->u.fontdir = first;

        return r;
    }
    static RES_RES *to_group_cursor(unsigned char *data, int length, int be)
    {
        RES_RES *r = AllocateMemory(sizeof(RES_RES));
        int type, c, i;
        struct group_cursor *first = NULL,  **pp = &first;

        checksize(length, 6);

        r->type = RST_GROUP_CURSOR;

        type = get_16(be, data + 2);
        if (type != 2)
            fatal("unexpected group cursor type %d", type);

        c = get_16(be, data + 4);

        data += 6;
        length -= 6;

        for (i = 0; i < c; i++)
        {
            struct group_cursor *gc = AllocateMemory(sizeof(struct group_cursor)
                );

            checksize(length, 14);

            gc->width = get_16(be, data);
            gc->height = get_16(be, data + 2);
            gc->planes = get_16(be, data + 4);
            gc->bits = get_16(be, data + 6);
            gc->bytes = get_32(be, data + 8);
            gc->index = get_16(be, data + 12);

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

            data += 14;
            length -= 14;
        } 

        r->u.group_cursor = first;

        return r;
    }
    static RES_RES *to_group_icon(unsigned char *data, int length, int be)
    {
        RES_RES *r = AllocateMemory(sizeof(RES_RES));
        int type, c, i;
        struct group_icon *first = NULL,  **pp = &first;

        r->type = RST_GROUP_ICON;

        checksize(length, 6);

        type = get_16(be, data + 2);
        if (type != 1)
            fatal("unexpected group icon type %d", type);

        c = get_16(be, data + 4);

        data += 6;
        length -= 6;

        for (i = 0; i < c; i++)
        {
            struct group_icon *gi = AllocateMemory(sizeof(struct group_icon));

            checksize(length, 14);

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

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

            data += 14;
            length -= 14;
        } 

        r->u.group_icon = first;

        return r;
    }
    static struct menuitem *to_menuitems(unsigned char *data, int length, int
        be, int *read)
    {
        struct menuitem *first = NULL,  **p = &first,  *mi;
        int flags, stroff, slen, itemlen;

        *read = 0;

        while (length > 0)
        {
            checksize(length, 4);
            mi = AllocateMemory(sizeof(*mi));
            mi->state = 0;
            mi->help = 0;

            mi->type = (flags = get_16(be, data)) &~(MI_POPUP | MI_ENDMENU);

            if ((flags &MI_POPUP) == 0)
                stroff = 4;
            else
                stroff = 2;

            checksize(length, stroff);

            mi->text = to_string(data + stroff, length - stroff, be, &slen);

            itemlen = stroff + slen * 2+2;

            if ((flags &MI_POPUP) == 0)
            {
                mi->popup = NULL;
                mi->id = get_16(be, data + 2);
            } 
            else
            {