Ignore:
Timestamp:
Apr 16, 2001, 7:11:03 PM (25 years ago)
Author:
sandervl
Message:

updates

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/tools/wrc/genres.c

    r3426 r5522  
    44 * Copyright 1998 Bertho A. Stultiens
    55 *
     6 * 05-May-2000 BS       - Added code to support endian conversions. The
     7 *                        extra functions also aid unaligned access, but
     8 *                        this is not yet implemented.
    69 * 25-May-1998 BS       - Added simple unicode -> char conversion for resource
    710 *                        names in .s and .h files. 
    … …  
    2023#include "utils.h"
    2124#include "windef.h"
     25#include "winbase.h"
    2226#include "wingdi.h"
    2327#include "winuser.h"
    2428
    25 #define SetResSize(res, tag)    *(DWORD *)&((res)->data[(tag)]) = \
    26                                 (res)->size - *(DWORD *)&((res)->data[(tag)])
     29#define SetResSize(res, tag)    set_dword((res), (tag), (res)->size - get_dword((res), (tag)))
    2730
    2831res_t *new_res(void)
    … …  
    6467        if(res->allocsize - res->size < sizeof(char))
    6568                grow_res(res, RES_BLOCKSIZE);
    66         *(char *)&(res->data[res->size]) = (char)c;
     69        res->data[res->size] = (char)c;
    6770        res->size += sizeof(char);
    6871}
    … …  
    7275        if(res->allocsize - res->size < sizeof(WORD))
    7376                grow_res(res, RES_BLOCKSIZE);
    74         *(WORD *)&(res->data[res->size]) = (WORD)w;
     77        switch(byteorder)
     78        {
     79#ifdef WORDS_BIGENDIAN
     80        default:
     81#endif
     82        case WRC_BO_BIG:
     83                res->data[res->size+0] = HIBYTE(w);
     84                res->data[res->size+1] = LOBYTE(w);
     85                break;
     86
     87#ifndef WORDS_BIGENDIAN
     88        default:
     89#endif
     90        case WRC_BO_LITTLE:
     91                res->data[res->size+1] = HIBYTE(w);
     92                res->data[res->size+0] = LOBYTE(w);
     93                break;
     94        }
    7595        res->size += sizeof(WORD);
    7696}
    … …  
    80100        if(res->allocsize - res->size < sizeof(DWORD))
    81101                grow_res(res, RES_BLOCKSIZE);
    82         *(DWORD *)&(res->data[res->size]) = (DWORD)d;
     102        switch(byteorder)
     103        {
     104#ifdef WORDS_BIGENDIAN
     105        default:
     106#endif
     107        case WRC_BO_BIG:
     108                res->data[res->size+0] = HIBYTE(HIWORD(d));
     109                res->data[res->size+1] = LOBYTE(HIWORD(d));
     110                res->data[res->size+2] = HIBYTE(LOWORD(d));
     111                res->data[res->size+3] = LOBYTE(LOWORD(d));
     112                break;
     113
     114#ifndef WORDS_BIGENDIAN
     115        default:
     116#endif
     117        case WRC_BO_LITTLE:
     118                res->data[res->size+3] = HIBYTE(HIWORD(d));
     119                res->data[res->size+2] = LOBYTE(HIWORD(d));
     120                res->data[res->size+1] = HIBYTE(LOWORD(d));
     121                res->data[res->size+0] = LOBYTE(LOWORD(d));
     122                break;
     123        }
    83124        res->size += sizeof(DWORD);
    84125}
    … …  
    88129        while(res->size & 0x3)
    89130                put_byte(res, 0);
     131}
     132
     133/*
     134 *****************************************************************************
     135 * Function     : set_word
     136 *                set_dword
     137 * Syntax       : void set_word(res_t *res, int ofs, unsigned w)
     138 *                void set_dword(res_t *res, int ofs, unsigned d)
     139 * Input        :
     140 *      res     - Binary resource to put the data in
     141 *      ofs     - Byte offset in data-array
     142 *      w, d    - Data to put
     143 * Output       : nop
     144 * Description  : Set the value of a binary resource data array to a
     145 *                specific value.
     146 * Remarks      :
     147 *****************************************************************************
     148*/
     149void set_word(res_t *res, int ofs, unsigned w)
     150{
     151        switch(byteorder)
     152        {
     153#ifdef WORDS_BIGENDIAN
     154        default:
     155#endif
     156        case WRC_BO_BIG:
     157                res->data[ofs+0] = HIBYTE(w);
     158                res->data[ofs+1] = LOBYTE(w);
     159                break;
     160
     161#ifndef WORDS_BIGENDIAN
     162        default:
     163#endif
     164        case WRC_BO_LITTLE:
     165                res->data[ofs+1] = HIBYTE(w);
     166                res->data[ofs+0] = LOBYTE(w);
     167                break;
     168        }
     169}
     170
     171void set_dword(res_t *res, int ofs, unsigned d)
     172{
     173        switch(byteorder)
     174        {
     175#ifdef WORDS_BIGENDIAN
     176        default:
     177#endif
     178        case WRC_BO_BIG:
     179                res->data[ofs+0] = HIBYTE(HIWORD(d));
     180                res->data[ofs+1] = LOBYTE(HIWORD(d));
     181                res->data[ofs+2] = HIBYTE(LOWORD(d));
     182                res->data[ofs+3] = LOBYTE(LOWORD(d));
     183                break;
     184
     185#ifndef WORDS_BIGENDIAN
     186        default:
     187#endif
     188        case WRC_BO_LITTLE:
     189                res->data[ofs+3] = HIBYTE(HIWORD(d));
     190                res->data[ofs+2] = LOBYTE(HIWORD(d));
     191                res->data[ofs+1] = HIBYTE(LOWORD(d));
     192                res->data[ofs+0] = LOBYTE(LOWORD(d));
     193                break;
     194        }
     195}
     196
     197/*
     198 *****************************************************************************
     199 * Function     : get_word
     200 *                get_dword
     201 * Syntax       : WORD get_word(res_t *res, int ofs)
     202 *                DWORD get_dword(res_t *res, int ofs)
     203 * Input        :
     204 *      res     - Binary resource to put the data in
     205 *      ofs     - Byte offset in data-array
     206 * Output       : The data in native endian
     207 * Description  : Get the value of a binary resource data array in native
     208 *                endian.
     209 * Remarks      :
     210 *****************************************************************************
     211*/
     212WORD get_word(res_t *res, int ofs)
     213{
     214        switch(byteorder)
     215        {
     216#ifdef WORDS_BIGENDIAN
     217        default:
     218#endif
     219        case WRC_BO_BIG:
     220                return   (res->data[ofs+0] << 8)
     221                       |  res->data[ofs+1];
     222
     223#ifndef WORDS_BIGENDIAN
     224        default:
     225#endif
     226        case WRC_BO_LITTLE:
     227                return   (res->data[ofs+1] << 8)
     228                       |  res->data[ofs+0];
     229        }
     230}
     231
     232DWORD get_dword(res_t *res, int ofs)
     233{
     234        switch(byteorder)
     235        {
     236#ifdef WORDS_BIGENDIAN
     237        default:
     238#endif
     239        case WRC_BO_BIG:
     240                return   (res->data[ofs+0] << 24)
     241                       | (res->data[ofs+1] << 16)
     242                       | (res->data[ofs+2] <<  8)
     243                       |  res->data[ofs+3];
     244
     245#ifndef WORDS_BIGENDIAN
     246        default:
     247#endif
     248        case WRC_BO_LITTLE:
     249                return   (res->data[ofs+3] << 24)
     250                       | (res->data[ofs+2] << 16)
     251                       | (res->data[ofs+1] <<  8)
     252                       |  res->data[ofs+0];
     253        }
    90254}
    91255
    … …  
    137301 *****************************************************************************
    138302*/
    139 void put_string(res_t *res, string_t *str, enum str_e type, int isterm)
     303static void put_string(res_t *res, string_t *str, enum str_e type, int isterm)
    140304{
    141305        int cnt;
    … …  
    149313        }
    150314
     315        str = convert_string(str, type);
    151316        if(str->type == str_unicode && type == str_unicode)
    152317        {
    … …  
    197362                        put_word(res, 0);
    198363        }
     364        free(str);
    199365}
    200366
    … …  
    255421        else
    256422                put_dword(res, 0);
     423        if(lvc && lvc->language)
     424            set_language( lvc->language->id, lvc->language->sub );
     425        else if (currentlanguage)
     426            set_language( currentlanguage->id, currentlanguage->sub );
     427        else
     428            set_language( LANG_NEUTRAL, SUBLANG_NEUTRAL );
    257429}
    258430
    … …  
    314486                put_word(res, memopt);          /* Memory options */
    315487                put_lvc(res, lvc);              /* Language, version and characts */
    316                 ((DWORD *)res->data)[0] = res->size;    /* Set preliminary resource */
    317                 ((DWORD *)res->data)[1] = res->size;    /* Set HeaderSize */
     488                set_dword(res, 0*sizeof(DWORD), res->size);     /* Set preliminary resource */
     489                set_dword(res, 1*sizeof(DWORD), res->size);     /* Set HeaderSize */
    318490                res->dataidx = res->size;
    319491                return 0;
    … …  
    333505                tag = res->size;
    334506                put_dword(res, 0);              /* ResSize overwritten later*/
    335                 *(DWORD *)&(res->data[tag]) = res->size;
     507                set_dword(res, tag, res->size);
    336508                res->dataidx = res->size;
    337509                return tag;
    … …  
    351523 *****************************************************************************
    352524*/
    353 res_t *accelerator2res(name_id_t *name, accelerator_t *acc)
     525static res_t *accelerator2res(name_id_t *name, accelerator_t *acc)
    354526{
    355527        int restag;
    … …  
    402574 *****************************************************************************
    403575*/
    404 res_t *dialog2res(name_id_t *name, dialog_t *dlg)
     576static res_t *dialog2res(name_id_t *name, dialog_t *dlg)
    405577{
    406578        int restag;
    … …  
    478650                }
    479651                /* Set number of controls */
    480                 *(WORD *)&((char *)res->data)[tag_nctrl] = (WORD)nctrl;
     652                set_word(res, tag_nctrl, (WORD)nctrl);
    481653        }
    482654        else /* win16 */
    … …  
    561733 *****************************************************************************
    562734*/
    563 res_t *dialogex2res(name_id_t *name, dialogex_t *dlgex)
     735static res_t *dialogex2res(name_id_t *name, dialogex_t *dlgex)
    564736{
    565737        int restag;
    … …  
    654826                }
    655827                /* Set number of controls */
    656                 *(WORD *)&((char *)res->data)[tag_nctrl] = (WORD)nctrl;
     828                set_word(res, tag_nctrl, (WORD)nctrl);
    657829                /* Set ResourceSize */
    658830                SetResSize(res, restag);
    … …  
    679851 *****************************************************************************
    680852*/
    681 void menuitem2res(res_t *res, menu_item_t *menitem)
     853static void menuitem2res(res_t *res, menu_item_t *menitem)
    682854{
    683855        menu_item_t *itm = menitem;
    … …  
    729901 *****************************************************************************
    730902*/
    731 res_t *menu2res(name_id_t *name, menu_t *men)
     903static res_t *menu2res(name_id_t *name, menu_t *men)
    732904{
    733905        int restag;
    … …  
    758930 *****************************************************************************
    759931*/
    760 void menuexitem2res(res_t *res, menuex_item_t *menitem)
     932static void menuexitem2res(res_t *res, menuex_item_t *menitem)
    761933{
    762934        menuex_item_t *itm = menitem;
    … …  
    795967 *****************************************************************************
    796968*/
    797 res_t *menuex2res(name_id_t *name, menuex_t *menex)
     969static res_t *menuex2res(name_id_t *name, menuex_t *menex)
    798970{
    799971        int restag;
    … …  
    8381010 *****************************************************************************
    8391011*/
    840 res_t *cursorgroup2res(name_id_t *name, cursor_group_t *curg)
     1012static res_t *cursorgroup2res(name_id_t *name, cursor_group_t *curg)
    8411013{
    8421014        int restag;
    … …  
    9461118 *****************************************************************************
    9471119*/
    948 res_t *cursor2res(cursor_t *cur)
     1120static res_t *cursor2res(cursor_t *cur)
    9491121{
    9501122        int restag;
    … …  
    9811153 *****************************************************************************
    9821154*/
    983 res_t *icongroup2res(name_id_t *name, icon_group_t *icog)
     1155static res_t *icongroup2res(name_id_t *name, icon_group_t *icog)
    9841156{
    9851157        int restag;
    … …  
    10491221 *****************************************************************************
    10501222*/
    1051 res_t *icon2res(icon_t *ico)
     1223static res_t *icon2res(icon_t *ico)
    10521224{
    10531225        int restag;
    … …  
    10721244/*
    10731245 *****************************************************************************
     1246 * Function     : anicurico2res
     1247 * Syntax       : res_t *anicurico2res(name_id_t *name, ani_curico_t *ani)
     1248 * Input        :
     1249 *      name    - Name/ordinal of the resource
     1250 *      ani     - The animated object descriptor
     1251 * Output       : New .res format structure
     1252 * Description  :
     1253 * Remarks      : The endian of the object's structures have been converted
     1254 *                by the loader.
     1255 *                There are rumors that win311 could handle animated stuff.
     1256 *                That is why they are generated for both win16 and win32
     1257 *                compile.
     1258 *****************************************************************************
     1259*/
     1260static res_t *anicurico2res(name_id_t *name, ani_curico_t *ani, enum res_e type)
     1261{
     1262        int restag;
     1263        res_t *res;
     1264        assert(name != NULL);
     1265        assert(ani != NULL);
     1266
     1267        res = new_res();
     1268        restag = put_res_header(res, type == res_anicur ? WRC_RT_ANICURSOR : WRC_RT_ANIICON,
     1269                                NULL, name, ani->memopt, NULL);
     1270        put_raw_data(res, ani->data, 0);
     1271        /* Set ResourceSize */
     1272        SetResSize(res, restag);
     1273        if(win32)
     1274                put_pad(res);
     1275        return res;
     1276}
     1277
     1278/*
     1279 *****************************************************************************
    10741280 * Function     : bitmap2res
    10751281 * Syntax       : res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
    … …  
    10791285 * Output       : New .res format structure
    10801286 * Description  :
    1081  * Remarks      :
    1082  *****************************************************************************
    1083 */
    1084 res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
     1287 * Remarks      : The endian of the bitmap structures have been converted
     1288 *                by the loader.
     1289 *****************************************************************************
     1290*/
     1291static res_t *bitmap2res(name_id_t *name, bitmap_t *bmp)
    10851292{
    10861293        int restag;
    … …  
    10891296        assert(bmp != NULL);
    10901297
    1091         HEAPCHECK();
    10921298        res = new_res();
    1093         HEAPCHECK();
    1094         restag = put_res_header(res, WRC_RT_BITMAP, NULL, name, bmp->memopt, NULL);
    1095         HEAPCHECK();
     1299        restag = put_res_header(res, WRC_RT_BITMAP, NULL, name, bmp->memopt, &(bmp->data->lvc));
    10961300        if(bmp->data->data[0] == 'B'
    10971301        && bmp->data->data[1] == 'M'
    … …  
    11061310                put_raw_data(res, bmp->data, 0);
    11071311        }
    1108         HEAPCHECK();
    11091312        /* Set ResourceSize */
    11101313        SetResSize(res, restag);
    1111         HEAPCHECK();
    1112         if(win32)
    1113                 put_pad(res);
    1114         HEAPCHECK();
     1314        if(win32)
     1315                put_pad(res);
    11151316        return res;
    11161317}
    … …  
    11251326 * Output       : New .res format structure
    11261327 * Description  :
    1127  * Remarks      :
    1128  *****************************************************************************
    1129 */
    1130 res_t *font2res(name_id_t *name, font_t *fnt)
    1131 {
     1328 * Remarks      : The data has been prepared just after parsing.
     1329 *****************************************************************************
     1330*/
     1331static res_t *font2res(name_id_t *name, font_t *fnt)
     1332{
     1333        int restag;
     1334        res_t *res;
    11321335        assert(name != NULL);
    11331336        assert(fnt != NULL);
    1134         warning("Fonts not yet implemented");
    1135         return NULL;
     1337
     1338        res = new_res();
     1339        restag = put_res_header(res, WRC_RT_FONT, NULL, name, fnt->memopt, &(fnt->data->lvc));
     1340        put_raw_data(res, fnt->data, 0);
     1341        /* Set ResourceSize */
     1342        SetResSize(res, restag);
     1343        if(win32)
     1344                put_pad(res);
     1345        return res;
     1346}
     1347
     1348/*
     1349 *****************************************************************************
     1350 * Function     : fontdir2res
     1351 * Syntax       : res_t *fontdir2res(name_id_t *name, fontdir_t *fnd)
     1352 * Input        :
     1353 *      name    - Name/ordinal of the resource
     1354 *      fntdir  - The fontdir descriptor
     1355 * Output       : New .res format structure
     1356 * Description  :
     1357 * Remarks      : The data has been prepared just after parsing.
     1358 *****************************************************************************
     1359*/
     1360static res_t *fontdir2res(name_id_t *name, fontdir_t *fnd)
     1361{
     1362        int restag;
     1363        res_t *res;
     1364        assert(name != NULL);
     1365        assert(fnd != NULL);
     1366
     1367        res = new_res();
     1368        restag = put_res_header(res, WRC_RT_FONTDIR, NULL, name, fnd->memopt, &(fnd->data->lvc));
     1369        put_raw_data(res, fnd->data, 0);
     1370        /* Set ResourceSize */
     1371        SetResSize(res, restag);
     1372        if(win32)
     1373                put_pad(res);
     1374        return res;
    11361375}
    11371376
    … …  
    11481387 *****************************************************************************
    11491388*/
    1150 res_t *rcdata2res(name_id_t *name, rcdata_t *rdt)
     1389static res_t *rcdata2res(name_id_t *name, rcdata_t *rdt)
    11511390{
    11521391        int restag;
    … …  
    11561395
    11571396        res = new_res();
    1158         restag = put_res_header(res, WRC_RT_RCDATA, NULL, name, rdt->memopt, NULL);
     1397        restag = put_res_header(res, WRC_RT_RCDATA, NULL, name, rdt->memopt, &(rdt->data->lvc));
    11591398        put_raw_data(res, rdt->data, 0);
    11601399        /* Set ResourceSize */
    … …  
    11741413 * Output       : New .res format structure
    11751414 * Description  :
    1176  * Remarks      :
    1177  *****************************************************************************
    1178 */
    1179 res_t *messagetable2res(name_id_t *name, messagetable_t *msg)
    1180 {
     1415 * Remarks      : The data has been converted to the appropriate endian
     1416 *                after is was parsed.
     1417 *****************************************************************************
     1418*/
     1419static res_t *messagetable2res(name_id_t *name, messagetable_t *msg)
     1420{
     1421        int restag;
     1422        res_t *res;
    11811423        assert(name != NULL);
    11821424        assert(msg != NULL);
    1183         warning("Messagetable not yet implemented");
    1184         return NULL;
     1425
     1426        res = new_res();
     1427        restag = put_res_header(res, WRC_RT_MESSAGETABLE, NULL, name, msg->memopt, &(msg->data->lvc));
     1428        put_raw_data(res, msg->data, 0);
     1429        /* Set ResourceSize */
     1430        SetResSize(res, restag);
     1431        if(win32)
     1432                put_pad(res);
     1433        return res;
    11851434}
    11861435
    … …  
    11961445 *****************************************************************************
    11971446*/
    1198 res_t *stringtable2res(stringtable_t *stt)
     1447static res_t *stringtable2res(stringtable_t *stt)
    11991448{
    12001449        res_t *res;
    … …  
    12191468                for(i = 0; i < stt->nentries; i++)
    12201469                {
    1221                         if(stt->entries[i].str)
     1470                        if(stt->entries[i].str && stt->entries[i].str->size)
    12221471                        {
    1223                                 if(win32)
    1224                                         put_word(res, stt->entries[i].str->size);
     1472                                string_t *str = convert_string(stt->entries[i].str, win32 ? str_unicode : str_char);
     1473                                if(win32)
     1474                                        put_word(res, str->size);
    12251475                                else
    1226                                         put_byte(res, stt->entries[i].str->size);
    1227                                 put_string(res, stt->entries[i].str, win32 ? str_unicode : str_char, FALSE);
     1476                                        put_byte(res, str->size);
     1477                                put_string(res, str, win32 ? str_unicode : str_char, FALSE);
     1478                                free(str);
    12281479                        }
    12291480                        else
    … …  
    12561507 *****************************************************************************
    12571508*/
    1258 res_t *user2res(name_id_t *name, user_t *usr)
     1509static res_t *user2res(name_id_t *name, user_t *usr)
    12591510{
    12601511        int restag;
    … …  
    12641515
    12651516        res = new_res();
    1266         restag = put_res_header(res, 0, usr->type, name, usr->memopt, NULL);
     1517        restag = put_res_header(res, 0, usr->type, name, usr->memopt, &(usr->data->lvc));
    12671518        put_raw_data(res, usr->data, 0);
    12681519        /* Set ResourceSize */
    … …  
    12851536 *****************************************************************************
    12861537*/
    1287 void versionblock2res(res_t *res, ver_block_t *blk, int level)
     1538static void versionblock2res(res_t *res, ver_block_t *blk, int level)
    12881539{
    12891540        ver_value_t *val;
    … …  
    13181569                        put_string(res, val->value.str, win32 ? str_unicode : str_char, TRUE);
    13191570                        if(win32)
    1320                                 *(WORD *)&(res->data[valvalsizetag]) = (WORD)((res->size - tag) >> 1);
     1571                                set_word(res, valvalsizetag, (WORD)((res->size - tag) >> 1));
    13211572                        else
    1322                                 *(WORD *)&(res->data[valvalsizetag]) = (WORD)(res->size - tag);
    1323                         *(WORD *)&(res->data[valblksizetag]) = (WORD)(res->size - valblksizetag);
     1573                                set_word(res, valvalsizetag, (WORD)(res->size - tag));
     1574                        set_word(res, valblksizetag, (WORD)(res->size - valblksizetag));
    13241575                        put_pad(res);
    13251576                }
    … …  
    13411592                                put_word(res, val->value.words->words[i]);
    13421593                        }
    1343                         *(WORD *)&(res->data[valvalsizetag]) = (WORD)(res->size - tag);
    1344                         *(WORD *)&(res->data[valblksizetag]) = (WORD)(res->size - valblksizetag);
     1594                        set_word(res, valvalsizetag, (WORD)(res->size - tag));
     1595                        set_word(res, valblksizetag, (WORD)(res->size - valblksizetag));
    13451596                        put_pad(res);
    13461597                }
    … …  
    13561607
    13571608        /* Set blocksize */
    1358         *(WORD *)&(res->data[blksizetag]) = (WORD)(res->size - blksizetag);
     1609        set_word(res, blksizetag, (WORD)(res->size - blksizetag));
    13591610}
    13601611
    … …  
    13711622 *****************************************************************************
    13721623*/
    1373 res_t *versioninfo2res(name_id_t *name, versioninfo_t *ver)
     1624static res_t *versioninfo2res(name_id_t *name, versioninfo_t *ver)
    13741625{
    13751626        int restag;
    … …  
    13891640
    13901641        res = new_res();
    1391         restag = put_res_header(res, WRC_RT_VERSION, NULL, name, WRC_MO_MOVEABLE | WRC_MO_PURE, NULL);
     1642        restag = put_res_header(res, WRC_RT_VERSION, NULL, name, ver->memopt, &(ver->lvc));
    13921643        rootblocksizetag = res->size;
    13931644        put_word(res, 0);       /* BlockSize filled in later */
    … …  
    14141665        put_dword(res, 0);              /* FileDateLS */
    14151666        /* Set ValueSize */
    1416         *(WORD *)&(res->data[valsizetag]) = (WORD)(res->size - tag);
     1667        set_word(res, valsizetag, (WORD)(res->size - tag));
    14171668        /* Descend into the blocks */
    14181669        for(blk = ver->blocks; blk; blk = blk->next)
    14191670                versionblock2res(res, blk, 0);
    14201671        /* Set root block's size */
    1421         *(WORD *)&(res->data[rootblocksizetag]) = (WORD)(res->size - rootblocksizetag);
     1672        set_word(res, rootblocksizetag, (WORD)(res->size - rootblocksizetag));
    14221673
    14231674        SetResSize(res, restag);
    … …  
    14381689 *****************************************************************************
    14391690*/
    1440 void toolbaritem2res(res_t *res, toolbar_item_t *tbitem)
     1691static void toolbaritem2res(res_t *res, toolbar_item_t *tbitem)
    14411692{
    14421693        toolbar_item_t *itm = tbitem;
    … …  
    14621713 *****************************************************************************
    14631714*/
    1464 res_t *toolbar2res(name_id_t *name, toolbar_t *toolbar)
     1715static res_t *toolbar2res(name_id_t *name, toolbar_t *toolbar)
    14651716{
    14661717        int restag;
    … …  
    15061757 *****************************************************************************
    15071758*/
    1508 res_t *dlginit2res(name_id_t *name, dlginit_t *dit)
     1759static res_t *dlginit2res(name_id_t *name, dlginit_t *dit)
    15091760{
    15101761        int restag;
    … …  
    15141765
    15151766        res = new_res();
    1516         restag = put_res_header(res, WRC_RT_DLGINIT, NULL, name, dit->memopt, &(dit->lvc));
     1767        restag = put_res_header(res, WRC_RT_DLGINIT, NULL, name, dit->memopt, &(dit->data->lvc));
    15171768        put_raw_data(res, dit->data, 0);
    15181769        /* Set ResourceSize */
    … …  
    15491800                for(i = 0; *sptr && i < MAXNAMELEN; i++)
    15501801                {
    1551                         if((unsigned)*sptr < 0x80 && isprint((char)*sptr))
     1802                        if((unsigned)*sptr < 0x80 && isprint(*sptr & 0xff))
    15521803                                buf[i] = *sptr++;
    15531804                        else
    … …  
    15641815                for(i = 0; *cptr && i < MAXNAMELEN; i++)
    15651816                {
    1566                         if((unsigned)*cptr < 0x80 && isprint(*cptr))
     1817                        if((unsigned)*cptr < 0x80 && isprint(*cptr & 0xff))
    15671818                                buf[i] = *cptr++;
    15681819                        else
    … …  
    16311882        {
    16321883        case res_acc:   return "Acc";
     1884        case res_anicur:return "AniCur";
     1885        case res_aniico:return "AniIco";
    16331886        case res_bmp:   return "Bmp";
    16341887        case res_cur:   return "Cur";
    … …  
    16371890        case res_dlgex: return "Dlg";
    16381891        case res_fnt:   return "Fnt";
     1892        case res_fntdir:return "FntDir";
    16391893        case res_ico:   return "Ico";
    16401894        case res_icog:  return "IcoGrp";
    … …  
    16961950                        if(!top->binres)
    16971951                                top->binres = font2res(top->name, top->res.fnt);
     1952                        break;
     1953                case res_fntdir:
     1954                        if(!top->binres)
     1955                                top->binres = fontdir2res(top->name, top->res.fnd);
    16981956                        break;
    16991957                case res_ico:
    … …  
    17411999                            top->binres = dlginit2res(top->name, top->res.dlgi);
    17422000                        break;
    1743 
     2001                case res_anicur:
     2002                case res_aniico:
     2003                        if(!top->binres)
     2004                            top->binres = anicurico2res(top->name, top->res.ani, top->type);
     2005                        break;
    17442006                default:
    17452007                        internal_error(__FILE__, __LINE__, "Unknown resource type encountered %d in binary res generation", top->type);
Note: See TracChangeset for help on using the changeset viewer.