loader/resource.c

   1 /*
   2  * Resources
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995 Alexandre Julliard
   6  */
   7
   8 #include <assert.h>
   9 #include <stdlib.h>
  10 #include <string.h>
  11 #include <sys/types.h>
  12 #include <sys/stat.h>
  13 #include <fcntl.h>
  14 #include <unistd.h>
  15 #include "winbase.h"
  16 #include "windef.h"
  17 #include "wingdi.h"
  18 #include "winuser.h"
  19 #include "wine/winbase16.h"
  20 #include "wine/winuser16.h"
  21 #include "ldt.h"
  22 #include "global.h"
  23 #include "heap.h"
  24 #include "callback.h"
  25 #include "cursoricon.h"
  26 #include "neexe.h"
  27 #include "task.h"
  28 #include "process.h"
  29 #include "module.h"
  30 #include "file.h"
  31 #include "debugtools.h"
  32 #include "winerror.h"
  33 #include "winnls.h"
  34
  35 DEFAULT_DEBUG_CHANNEL(resource);
  36 DECLARE_DEBUG_CHANNEL(accel);
  37
  38 extern WORD WINE_LanguageId;
  39
  40 #define HRSRC_MAP_BLOCKSIZE 16
  41
  42 typedef struct _HRSRC_ELEM
  43 {
  44     HANDLE hRsrc;
  45     WORD     type;
  46 } HRSRC_ELEM;
  47
  48 typedef struct _HRSRC_MAP
  49 {
  50     int nAlloc;
  51     int nUsed;
  52     HRSRC_ELEM *elem;
  53 } HRSRC_MAP;
  54
  55 /**********************************************************************
  56  *          MapHRsrc32To16
  57  */
  58 static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HANDLE hRsrc32, WORD type )
  59 {
  60     HRSRC_MAP *map = (HRSRC_MAP *)pModule->hRsrcMap;
  61     HRSRC_ELEM *newElem;
  62     int i;
  63
  64     /* On first call, initialize HRSRC map */
  65     if ( !map )
  66     {
  67         if ( !(map = (HRSRC_MAP *)HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
  68                                              sizeof(HRSRC_MAP) ) ) )
  69         {
  70             ERR("Cannot allocate HRSRC map\n" );
  71             return 0;
  72         }
  73         pModule->hRsrcMap = (LPVOID)map;
  74     }
  75
  76     /* Check whether HRSRC32 already in map */
  77     for ( i = 0; i < map->nUsed; i++ )
  78         if ( map->elem[i].hRsrc == hRsrc32 )
  79             return (HRSRC16)(i + 1);
  80
  81     /* If no space left, grow table */
  82     if ( map->nUsed == map->nAlloc )
  83     {
  84         if ( !(newElem = (HRSRC_ELEM *)HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
  85                                                     map->elem,
  86                                                     (map->nAlloc + HRSRC_MAP_BLOCKSIZE)
  87                                                     * sizeof(HRSRC_ELEM) ) ))
  88         {
  89             ERR("Cannot grow HRSRC map\n" );
  90             return 0;
  91         }
  92         map->elem = newElem;
  93         map->nAlloc += HRSRC_MAP_BLOCKSIZE;
  94     }
  95
  96     /* Add HRSRC32 to table */
  97     map->elem[map->nUsed].hRsrc = hRsrc32;
  98     map->elem[map->nUsed].type  = type;
  99     map->nUsed++;
 100
 101     return (HRSRC16)map->nUsed;
 102 }
 103
 104 /**********************************************************************
 105  *          MapHRsrc16To32
 106  */
 107 static HANDLE MapHRsrc16To32( NE_MODULE *pModule, HRSRC16 hRsrc16 )
 108 {
 109     HRSRC_MAP *map = (HRSRC_MAP *)pModule->hRsrcMap;
 110     if ( !map || !hRsrc16 || (int)hRsrc16 > map->nUsed ) return 0;
 111
 112     return map->elem[(int)hRsrc16-1].hRsrc;
 113 }
 114
 115 /**********************************************************************
 116  *          MapHRsrc16ToType
 117  */
 118 static WORD MapHRsrc16ToType( NE_MODULE *pModule, HRSRC16 hRsrc16 )
 119 {
 120     HRSRC_MAP *map = (HRSRC_MAP *)pModule->hRsrcMap;
 121     if ( !map || !hRsrc16 || (int)hRsrc16 > map->nUsed ) return 0;
 122
 123     return map->elem[(int)hRsrc16-1].type;
 124 }
 125
 126
 127 /**********************************************************************
 128  *          RES_FindResource
 129  */
 130 static HRSRC RES_FindResource( HMODULE hModule, LPCSTR type,
 131                                LPCSTR name, WORD lang,
 132                                BOOL bUnicode, BOOL bRet16 )
 133 {
 134     HRSRC hRsrc = 0;
 135
 136     HMODULE16 hMod16   = MapHModuleLS( hModule );
 137     NE_MODULE *pModule = NE_GetPtr( hMod16 );
 138     WINE_MODREF *wm    = pModule && pModule->module32?
 139                          MODULE32_LookupHMODULE( pModule->module32 ) : NULL;
 140
 141     TRACE("(%08x %s, %08x%s, %08x%s, %04x, %s, %s)\n",
 142           hModule,
 143           pModule ? (char *)NE_MODULE_NAME(pModule) : "NULL dereference",
 144           (UINT)type, HIWORD(type)? (bUnicode? debugstr_w((LPWSTR)type) : debugstr_a(type)) : "",
 145           (UINT)name, HIWORD(name)? (bUnicode? debugstr_w((LPWSTR)name) : debugstr_a(name)) : "",
 146           lang,
 147           bUnicode? "W"  : "A",
 148           bRet16?   "NE" : "PE" );
 149
 150     if ( !pModule ) return 0;
 151
 152     if ( wm )
 153     {
 154         /* 32-bit PE module */
 155         LPWSTR typeStr, nameStr;
 156
 157         if ( HIWORD( type ) && !bUnicode )
 158             typeStr = HEAP_strdupAtoW( GetProcessHeap(), 0, type );
 159         else
 160             typeStr = (LPWSTR)type;
 161         if ( HIWORD( name ) && !bUnicode )
 162             nameStr = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
 163         else
 164             nameStr = (LPWSTR)name;
 165
 166         hRsrc = PE_FindResourceExW( wm, nameStr, typeStr, lang );
 167
 168         if ( HIWORD( type ) && !bUnicode )
 169             HeapFree( GetProcessHeap(), 0, typeStr );
 170         if ( HIWORD( name ) && !bUnicode )
 171             HeapFree( GetProcessHeap(), 0, nameStr );
 172
 173
 174         /* If we need to return 16-bit HRSRC, perform conversion */
 175         if ( bRet16 )
 176             hRsrc = MapHRsrc32To16( pModule, hRsrc,
 177                                     HIWORD( type )? 0 : LOWORD( type ) );
 178     }
 179     else
 180     {
 181         /* 16-bit NE module */
 182         LPSTR typeStr, nameStr;
 183
 184         if ( HIWORD( type ) && bUnicode )
 185             typeStr = HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)type );
 186         else
 187             typeStr = (LPSTR)type;
 188         if ( HIWORD( name ) && bUnicode )
 189             nameStr = HEAP_strdupWtoA( GetProcessHeap(), 0, (LPCWSTR)name );
 190         else
 191             nameStr = (LPSTR)name;
 192
 193         hRsrc = NE_FindResource( pModule, nameStr, typeStr );
 194
 195         if ( HIWORD( type ) && bUnicode )
 196             HeapFree( GetProcessHeap(), 0, typeStr );
 197         if ( HIWORD( name ) && bUnicode )
 198             HeapFree( GetProcessHeap(), 0, nameStr );
 199
 200
 201         /* If we need to return 32-bit HRSRC, no conversion is necessary,
 202            we simply use the 16-bit HRSRC as 32-bit HRSRC */
 203     }
 204
 205     return hRsrc;
 206 }
 207
 208 /**********************************************************************
 209  *          RES_SizeofResource
 210  */
 211 static DWORD RES_SizeofResource( HMODULE hModule, HRSRC hRsrc, BOOL bRet16 )
 212 {
 213     DWORD size = 0;
 214
 215     HMODULE16 hMod16   = MapHModuleLS( hModule );
 216     NE_MODULE *pModule = NE_GetPtr( hMod16 );
 217     WINE_MODREF *wm    = pModule && pModule->module32?
 218                          MODULE32_LookupHMODULE( pModule->module32 ) : NULL;
 219
 220     TRACE("(%08x %s, %08x, %s)\n",
 221           hModule, NE_MODULE_NAME(pModule), hRsrc, bRet16? "NE" : "PE" );
 222
 223     if ( !pModule || !hRsrc ) return 0;
 224
 225     if ( wm )
 226     {
 227         /* 32-bit PE module */
 228
 229         /* If we got a 16-bit hRsrc, convert it */
 230         HRSRC hRsrc32 = HIWORD(hRsrc)? hRsrc : MapHRsrc16To32( pModule, hRsrc );
 231
 232         size = PE_SizeofResource( hModule, hRsrc32 );
 233     }
 234     else
 235     {
 236         /* 16-bit NE module */
 237
 238         /* If we got a 32-bit hRsrc, we don't need to convert it */
 239
 240         size = NE_SizeofResource( pModule, hRsrc );
 241     }
 242
 243     return size;
 244 }
 245
 246 /**********************************************************************
 247  *          RES_AccessResource
 248  */
 249 static HFILE RES_AccessResource( HMODULE hModule, HRSRC hRsrc, BOOL bRet16 )
 250 {
 251     HFILE hFile = HFILE_ERROR;
 252
 253     HMODULE16 hMod16   = MapHModuleLS( hModule );
 254     NE_MODULE *pModule = NE_GetPtr( hMod16 );
 255     WINE_MODREF *wm    = pModule && pModule->module32?
 256                          MODULE32_LookupHMODULE( pModule->module32 ) : NULL;
 257
 258     TRACE("(%08x %s, %08x, %s)\n",
 259           hModule, NE_MODULE_NAME(pModule), hRsrc, bRet16? "NE" : "PE" );
 260
 261     if ( !pModule || !hRsrc ) return HFILE_ERROR;
 262
 263     if ( wm )
 264     {
 265         /* 32-bit PE module */
 266 #if 0
 267         /* If we got a 16-bit hRsrc, convert it */
 268         HRSRC hRsrc32 = HIWORD(hRsrc)? hRsrc : MapHRsrc16To32( pModule, hRsrc );
 269 #endif
 270
 271         FIXME("32-bit modules not yet supported.\n" );
 272         hFile = HFILE_ERROR;
 273
 274         /* If we need to return a 16-bit file handle, convert it */
 275         if ( bRet16 )
 276             hFile = FILE_AllocDosHandle( hFile );
 277     }
 278     else
 279     {
 280         /* 16-bit NE module */
 281
 282         /* If we got a 32-bit hRsrc, we don't need to convert it */
 283
 284         hFile = NE_AccessResource( pModule, hRsrc );
 285
 286         /* If we are to return a 32-bit file handle, convert it */
 287         if ( !bRet16 )
 288             hFile = FILE_GetHandle( hFile );
 289     }
 290
 291     return hFile;
 292 }
 293
 294 /**********************************************************************
 295  *          RES_LoadResource
 296  */
 297 static HGLOBAL RES_LoadResource( HMODULE hModule, HRSRC hRsrc, BOOL bRet16 )
 298 {
 299     HGLOBAL hMem = 0;
 300
 301     HMODULE16 hMod16   = MapHModuleLS( hModule );
 302     NE_MODULE *pModule = NE_GetPtr( hMod16 );
 303     WINE_MODREF *wm    = pModule && pModule->module32?
 304                          MODULE32_LookupHMODULE( pModule->module32 ) : NULL;
 305
 306     TRACE("(%08x %s, %08x, %s)\n",
 307           hModule, NE_MODULE_NAME(pModule), hRsrc, bRet16? "NE" : "PE" );
 308
 309     if ( !pModule || !hRsrc ) return 0;
 310
 311     if ( wm )
 312     {
 313         /* 32-bit PE module */
 314
 315         /* If we got a 16-bit hRsrc, convert it */
 316         HRSRC hRsrc32 = HIWORD(hRsrc)? hRsrc : MapHRsrc16To32( pModule, hRsrc );
 317
 318         hMem = PE_LoadResource( wm, hRsrc32 );
 319
 320         /* If we need to return a 16-bit resource, convert it */
 321         if ( bRet16 )
 322         {
 323             WORD type   = MapHRsrc16ToType( pModule, hRsrc );
 324             DWORD size  = SizeofResource( hModule, hRsrc );
 325             LPVOID bits = LockResource( hMem );
 326
 327             hMem = NE_LoadPEResource( pModule, type, bits, size );
 328         }
 329     }
 330     else
 331     {
 332         /* 16-bit NE module */
 333
 334         /* If we got a 32-bit hRsrc, we don't need to convert it */
 335
 336         hMem = NE_LoadResource( pModule, hRsrc );
 337
 338         /* If we are to return a 32-bit resource, we should probably
 339            convert it but we don't for now.  FIXME !!! */
 340     }
 341
 342     return hMem;
 343 }
 344
 345 /**********************************************************************
 346  *          RES_LockResource
 347  */
 348 static LPVOID RES_LockResource( HGLOBAL handle, BOOL bRet16 )
 349 {
 350     LPVOID bits = NULL;
 351
 352     TRACE("(%08x, %s)\n", handle, bRet16? "NE" : "PE" );
 353
 354     if ( HIWORD( handle ) )
 355     {
 356         /* 32-bit memory handle */
 357
 358         if ( bRet16 )
 359             FIXME("can't return SEGPTR to 32-bit resource %08x.\n", handle );
 360         else
 361             bits = (LPVOID)handle;
 362     }
 363     else
 364     {
 365         /* 16-bit memory handle */
 366
 367         /* May need to reload the resource if discarded */
 368         SEGPTR segPtr = WIN16_GlobalLock16( handle );
 369
 370         if ( bRet16 )
 371             bits = (LPVOID)segPtr;
 372         else
 373             bits = PTR_SEG_TO_LIN( segPtr );
 374     }
 375
 376     return bits;
 377 }
 378
 379 /**********************************************************************
 380  *          RES_FreeResource
 381  */
 382 static BOOL RES_FreeResource( HGLOBAL handle )
 383 {
 384     HGLOBAL retv = handle;
 385
 386     TRACE("(%08x)\n", handle );
 387
 388     if ( HIWORD( handle ) )
 389     {
 390         /* 32-bit memory handle: nothing to do */
 391     }
 392     else
 393     {
 394         /* 16-bit memory handle */
 395         NE_MODULE *pModule = NE_GetPtr( FarGetOwner16( handle ) );
 396
 397         /* Try NE resource first */
 398         retv = NE_FreeResource( pModule, handle );
 399
 400         /* If this failed, call USER.DestroyIcon32; this will check
 401            whether it is a shared cursor/icon; if not it will call
 402            GlobalFree16() */
 403         if ( retv ) {
 404             if ( Callout.DestroyIcon32 )
 405                 retv = Callout.DestroyIcon32( handle, CID_RESOURCE );
 406             else
 407                 retv = GlobalFree16( handle );
 408         }
 409     }
 410
 411     return (BOOL)retv;
 412 }
 413
 414
 415 /**********************************************************************
 416  *          FindResource16   (KERNEL.60)
 417  */
 418 HRSRC16 WINAPI FindResource16( HMODULE16 hModule, SEGPTR name, SEGPTR type )
 419 {
 420     LPCSTR nameStr = HIWORD(name)? PTR_SEG_TO_LIN(name) : (LPCSTR)name;
 421     LPCSTR typeStr = HIWORD(type)? PTR_SEG_TO_LIN(type) : (LPCSTR)type;
 422
 423     return RES_FindResource( hModule, typeStr, nameStr,
 424                              WINE_LanguageId, FALSE, TRUE );
 425 }
 426
 427 /**********************************************************************
 428  *          FindResourceA    (KERNEL32.128)
 429  */
 430 HANDLE WINAPI FindResourceA( HMODULE hModule, LPCSTR name, LPCSTR type )
 431 {
 432     return RES_FindResource( hModule, type, name,
 433                              WINE_LanguageId, FALSE, FALSE );
 434 }
 435
 436 /**********************************************************************
 437  *          FindResourceExA  (KERNEL32.129)
 438  */
 439 HANDLE WINAPI FindResourceExA( HMODULE hModule,
 440                                LPCSTR type, LPCSTR name, WORD lang )
 441 {
 442     return RES_FindResource( hModule, type, name,
 443                              lang, FALSE, FALSE );
 444 }
 445
 446 /**********************************************************************
 447  *          FindResourceExW  (KERNEL32.130)
 448  */
 449 HRSRC WINAPI FindResourceExW( HMODULE hModule,
 450                               LPCWSTR type, LPCWSTR name, WORD lang )
 451 {
 452     return RES_FindResource( hModule, (LPCSTR)type, (LPCSTR)name,
 453                              lang, TRUE, FALSE );
 454 }
 455
 456 /**********************************************************************
 457  *          FindResourceW    (KERNEL32.131)
 458  */
 459 HRSRC WINAPI FindResourceW(HINSTANCE hModule, LPCWSTR name, LPCWSTR type)
 460 {
 461     return RES_FindResource( hModule, (LPCSTR)type, (LPCSTR)name,
 462                              WINE_LanguageId, TRUE, FALSE );
 463 }
 464
 465 /**********************************************************************
 466  *          LoadResource16   (KERNEL.61)
 467  */
 468 HGLOBAL16 WINAPI LoadResource16( HMODULE16 hModule, HRSRC16 hRsrc )
 469 {
 470     return RES_LoadResource( hModule, hRsrc, TRUE );
 471 }
 472
 473 /**********************************************************************
 474  *          LoadResource     (KERNEL32.370)
 475  */
 476 HGLOBAL WINAPI LoadResource( HINSTANCE hModule, HRSRC hRsrc )
 477 {
 478     return RES_LoadResource( hModule, hRsrc, FALSE );
 479 }
 480
 481 /**********************************************************************
 482  *          LockResource16   (KERNEL.62)
 483  */
 484 SEGPTR WINAPI WIN16_LockResource16( HGLOBAL16 handle )
 485 {
 486     return (SEGPTR)RES_LockResource( handle, TRUE );
 487 }
 488 LPVOID WINAPI LockResource16( HGLOBAL16 handle )
 489 {
 490     return RES_LockResource( handle, FALSE );
 491 }
 492
 493 /**********************************************************************
 494  *          LockResource     (KERNEL32.384)
 495  */
 496 LPVOID WINAPI LockResource( HGLOBAL handle )
 497 {
 498     return RES_LockResource( handle, FALSE );
 499 }
 500
 501 /**********************************************************************
 502  *          FreeResource16   (KERNEL.63)
 503  */
 504 BOOL16 WINAPI FreeResource16( HGLOBAL16 handle )
 505 {
 506     return RES_FreeResource( handle );
 507 }
 508
 509 /**********************************************************************
 510  *          FreeResource     (KERNEL32.145)
 511  */
 512 BOOL WINAPI FreeResource( HGLOBAL handle )
 513 {
 514     return RES_FreeResource( handle );
 515 }
 516
 517 /**********************************************************************
 518  *          AccessResource16 (KERNEL.64)
 519  */
 520 INT16 WINAPI AccessResource16( HINSTANCE16 hModule, HRSRC16 hRsrc )
 521 {
 522     return RES_AccessResource( hModule, hRsrc, TRUE );
 523 }
 524
 525 /**********************************************************************
 526  *          AccessResource   (KERNEL32.64)
 527  */
 528 INT WINAPI AccessResource( HMODULE hModule, HRSRC hRsrc )
 529 {
 530     return RES_AccessResource( hModule, hRsrc, FALSE );
 531 }
 532
 533 /**********************************************************************
 534  *          SizeofResource16 (KERNEL.65)
 535  */
 536 DWORD WINAPI SizeofResource16( HMODULE16 hModule, HRSRC16 hRsrc )
 537 {
 538     return RES_SizeofResource( hModule, hRsrc, TRUE );
 539 }
 540
 541 /**********************************************************************
 542  *          SizeofResource   (KERNEL32.522)
 543  */
 544 DWORD WINAPI SizeofResource( HINSTANCE hModule, HRSRC hRsrc )
 545 {
 546     return RES_SizeofResource( hModule, hRsrc, FALSE );
 547 }
 548
 549
 550
 551 /**********************************************************************
 552  *                      LoadAccelerators16      [USER.177]
 553  */
 554 HACCEL16 WINAPI LoadAccelerators16(HINSTANCE16 instance, SEGPTR lpTableName)
 555 {
 556     HRSRC16     hRsrc;
 557
 558     if (HIWORD(lpTableName))
 559         TRACE_(accel)("%04x '%s'\n",
 560                       instance, (char *)PTR_SEG_TO_LIN( lpTableName ) );
 561     else
 562         TRACE_(accel)("%04x %04x\n",
 563                        instance, LOWORD(lpTableName) );
 564
 565     if (!(hRsrc = FindResource16( instance, lpTableName, RT_ACCELERATOR16 ))) {
 566       WARN_(accel)("couldn't find accelerator table resource\n");
 567       return 0;
 568     }
 569
 570     TRACE_(accel)("returning HACCEL 0x%x\n", hRsrc);
 571     return LoadResource16(instance,hRsrc);
 572 }
 573
 574 /**********************************************************************
 575  *                      LoadAccelerators32W     [USER.177]
 576  * The image layout seems to look like this (not 100% sure):
 577  * 00:  BYTE    type            type of accelerator
 578  * 01:  BYTE    pad             (to WORD boundary)
 579  * 02:  WORD    event
 580  * 04:  WORD    IDval
 581  * 06:  WORD    pad             (to DWORD boundary)
 582  */
 583 HACCEL WINAPI LoadAcceleratorsW(HINSTANCE instance,LPCWSTR lpTableName)
 584 {
 585     HRSRC hRsrc;
 586     HACCEL hMem,hRetval=0;
 587     DWORD size;
 588
 589     if (HIWORD(lpTableName))
 590         TRACE_(accel)("%p '%s'\n",
 591                       (LPVOID)instance, (char *)( lpTableName ) );
 592     else
 593         TRACE_(accel)("%p 0x%04x\n",
 594                        (LPVOID)instance, LOWORD(lpTableName) );
 595
 596     if (!(hRsrc = FindResourceW( instance, lpTableName, RT_ACCELERATORW )))
 597     {
 598       WARN_(accel)("couldn't find accelerator table resource\n");
 599     } else {
 600       hMem = LoadResource( instance, hRsrc );
 601       size = SizeofResource( instance, hRsrc );
 602       if(size>=sizeof(PE_ACCEL))
 603       {
 604         LPPE_ACCEL accel_table = (LPPE_ACCEL) hMem;
 605         LPACCEL16 accel16;
 606         int i,nrofaccells = size/sizeof(PE_ACCEL);
 607
 608         hRetval = GlobalAlloc16(0,sizeof(ACCEL16)*nrofaccells);
 609         accel16 = (LPACCEL16)GlobalLock16(hRetval);
 610         for (i=0;i<nrofaccells;i++) {
 611                 accel16[i].fVirt = accel_table[i].fVirt;
 612                 accel16[i].key = accel_table[i].key;
 613                 accel16[i].cmd = accel_table[i].cmd;
 614         }
 615         accel16[i-1].fVirt |= 0x80;
 616       }
 617     }
 618     TRACE_(accel)("returning HACCEL 0x%x\n", hRsrc);
 619     return hRetval;
 620 }
 621
 622 HACCEL WINAPI LoadAcceleratorsA(HINSTANCE instance,LPCSTR lpTableName)
 623 {
 624         LPWSTR   uni;
 625         HACCEL result;
 626         if (HIWORD(lpTableName))
 627                 uni = HEAP_strdupAtoW( GetProcessHeap(), 0, lpTableName );
 628         else
 629                 uni = (LPWSTR)lpTableName;
 630         result = LoadAcceleratorsW(instance,uni);
 631         if (HIWORD(uni)) HeapFree( GetProcessHeap(), 0, uni);
 632         return result;
 633 }
 634
 635 /**********************************************************************
 636  *             CopyAcceleratorTable32A   (USER32.58)
 637  */
 638 INT WINAPI CopyAcceleratorTableA(HACCEL src, LPACCEL dst, INT entries)
 639 {
 640   return CopyAcceleratorTableW(src, dst, entries);
 641 }
 642
 643 /**********************************************************************
 644  *             CopyAcceleratorTable32W   (USER32.59)
 645  *
 646  * By mortene@pvv.org 980321
 647  */
 648 INT WINAPI CopyAcceleratorTableW(HACCEL src, LPACCEL dst,
 649                                      INT entries)
 650 {
 651   int i,xsize;
 652   LPACCEL16 accel = (LPACCEL16)GlobalLock16(src);
 653   BOOL done = FALSE;
 654
 655   /* Do parameter checking to avoid the explosions and the screaming
 656      as far as possible. */
 657   if((dst && (entries < 1)) || (src == (HACCEL)NULL) || !accel) {
 658     WARN_(accel)("Application sent invalid parameters (%p %p %d).\n",
 659          (LPVOID)src, (LPVOID)dst, entries);
 660     return 0;
 661   }
 662   xsize = GlobalSize16(src)/sizeof(ACCEL16);
 663   if (xsize>entries) entries=xsize;
 664
 665   i=0;
 666   while(!done) {
 667     /* Spit out some debugging information. */
 668     TRACE_(accel)("accel %d: type 0x%02x, event '%c', IDval 0x%04x.\n",
 669           i, accel[i].fVirt, accel[i].key, accel[i].cmd);
 670
 671     /* Copy data to the destination structure array (if dst == NULL,
 672        we're just supposed to count the number of entries). */
 673     if(dst) {
 674       dst[i].fVirt = accel[i].fVirt;
 675       dst[i].key = accel[i].key;
 676       dst[i].cmd = accel[i].cmd;
 677
 678       /* Check if we've reached the end of the application supplied
 679          accelerator table. */
 680       if(i+1 == entries) {
 681         /* Turn off the high order bit, just in case. */
 682         dst[i].fVirt &= 0x7f;
 683         done = TRUE;
 684       }
 685     }
 686
 687     /* The highest order bit seems to mark the end of the accelerator
 688        resource table, but not always. Use GlobalSize() check too. */
 689     if((accel[i].fVirt & 0x80) != 0) done = TRUE;
 690
 691     i++;
 692   }
 693
 694   return i;
 695 }
 696
 697 /*********************************************************************
 698  *                    CreateAcceleratorTable   (USER32.64)
 699  *
 700  * By mortene@pvv.org 980321
 701  */
 702 HACCEL WINAPI CreateAcceleratorTableA(LPACCEL lpaccel, INT cEntries)
 703 {
 704   HACCEL        hAccel;
 705   LPACCEL16     accel;
 706   int           i;
 707
 708   /* Do parameter checking just in case someone's trying to be
 709      funny. */
 710   if(cEntries < 1) {
 711     WARN_(accel)("Application sent invalid parameters (%p %d).\n",
 712          lpaccel, cEntries);
 713     SetLastError(ERROR_INVALID_PARAMETER);
 714     return (HACCEL)NULL;
 715   }
 716   FIXME_(accel)("should check that the accelerator descriptions are valid,"
 717         " return NULL and SetLastError() if not.\n");
 718
 719
 720   /* Allocate memory and copy the table. */
 721   hAccel = GlobalAlloc16(0,cEntries*sizeof(ACCEL16));
 722
 723   TRACE_(accel)("handle %x\n", hAccel);
 724   if(!hAccel) {
 725     ERR_(accel)("Out of memory.\n");
 726     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 727     return (HACCEL)NULL;
 728   }
 729   accel = GlobalLock16(hAccel);
 730   for (i=0;i<cEntries;i++) {
 731         accel[i].fVirt = lpaccel[i].fVirt;
 732         accel[i].key = lpaccel[i].key;
 733         accel[i].cmd = lpaccel[i].cmd;
 734   }
 735   /* Set the end-of-table terminator. */
 736   accel[cEntries-1].fVirt |= 0x80;
 737
 738   TRACE_(accel)("Allocated accelerator handle %x\n", hAccel);
 739   return hAccel;
 740 }
 741
 742 /*********************************************************************
 743  *                    CreateAcceleratorTableW   (USER32.64)
 744  *
 745  *
 746  */
 747 HACCEL WINAPI CreateAcceleratorTableW(LPACCEL lpaccel, INT cEntries)
 748 {
 749   HACCEL        hAccel;
 750   LPACCEL16     accel;
 751   int           i;
 752   char          ckey;
 753
 754   /* Do parameter checking just in case someone's trying to be
 755      funny. */
 756   if(cEntries < 1) {
 757     WARN_(accel)("Application sent invalid parameters (%p %d).\n",
 758          lpaccel, cEntries);
 759     SetLastError(ERROR_INVALID_PARAMETER);
 760     return (HACCEL)NULL;
 761   }
 762   FIXME_(accel)("should check that the accelerator descriptions are valid,"
 763         " return NULL and SetLastError() if not.\n");
 764
 765
 766   /* Allocate memory and copy the table. */
 767   hAccel = GlobalAlloc16(0,cEntries*sizeof(ACCEL16));
 768
 769   TRACE_(accel)("handle %x\n", hAccel);
 770   if(!hAccel) {
 771     ERR_(accel)("Out of memory.\n");
 772     SetLastError(ERROR_NOT_ENOUGH_MEMORY);
 773     return (HACCEL)NULL;
 774   }
 775   accel = GlobalLock16(hAccel);
 776
 777
 778   for (i=0;i<cEntries;i++) {
 779        accel[i].fVirt = lpaccel[i].fVirt;
 780        if( !(accel[i].fVirt & FVIRTKEY) ) {
 781           ckey = (char) lpaccel[i].key;
 782          if(!MultiByteToWideChar(CP_ACP, MB_PRECOMPOSED, &ckey, 1, &accel[i].key, 1))
 783             WARN_(accel)("Error converting ASCII accelerator table to Unicode");
 784        }
 785        else
 786          accel[i].key = lpaccel[i].key;
 787        accel[i].cmd = lpaccel[i].cmd;
 788   }
 789
 790   /* Set the end-of-table terminator. */
 791   accel[cEntries-1].fVirt |= 0x80;
 792
 793   TRACE_(accel)("Allocated accelerator handle %x\n", hAccel);
 794   return hAccel;
 795 }
 796
 797 /******************************************************************************
 798  * DestroyAcceleratorTable [USER32.130]
 799  * Destroys an accelerator table
 800  *
 801  * NOTES
 802  *    By mortene@pvv.org 980321
 803  *
 804  * PARAMS
 805  *    handle [I] Handle to accelerator table
 806  *
 807  * RETURNS STD
 808  */
 809 BOOL WINAPI DestroyAcceleratorTable( HACCEL handle )
 810 {
 811     return GlobalFree16(handle);
 812 }
 813
 814 /**********************************************************************
 815  *                                      LoadString16
 816  */
 817 INT16 WINAPI LoadString16( HINSTANCE16 instance, UINT16 resource_id,
 818                            LPSTR buffer, INT16 buflen )
 819 {
 820     HGLOBAL16 hmem;
 821     HRSRC16 hrsrc;
 822     unsigned char *p;
 823     int string_num;
 824     int i;
 825
 826     TRACE("inst=%04x id=%04x buff=%08x len=%d\n",
 827           instance, resource_id, (int) buffer, buflen);
 828
 829     hrsrc = FindResource16( instance, (SEGPTR)((resource_id>>4)+1), RT_STRING16 );
 830     if (!hrsrc) return 0;
 831     hmem = LoadResource16( instance, hrsrc );
 832     if (!hmem) return 0;
 833
 834     p = LockResource16(hmem);
 835     string_num = resource_id & 0x000f;
 836     for (i = 0; i < string_num; i++)
 837         p += *p + 1;
 838
 839     TRACE("strlen = %d\n", (int)*p );
 840
 841     if (buffer == NULL) return *p;
 842     i = min(buflen - 1, *p);
 843     if (i > 0) {
 844         memcpy(buffer, p + 1, i);
 845         buffer[i] = '\0';
 846     } else {
 847         if (buflen > 1) {
 848             buffer[0] = '\0';
 849             return 0;
 850         }
 851         WARN("Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
 852     }
 853     FreeResource16( hmem );
 854
 855     TRACE("'%s' loaded !\n", buffer);
 856     return i;
 857 }
 858
 859 /**********************************************************************
 860  *      LoadString32W           (USER32.376)
 861  */
 862 INT WINAPI LoadStringW( HINSTANCE instance, UINT resource_id,
 863                             LPWSTR buffer, INT buflen )
 864 {
 865     HGLOBAL hmem;
 866     HRSRC hrsrc;
 867     WCHAR *p;
 868     int string_num;
 869     int i;
 870
 871     if (HIWORD(resource_id)==0xFFFF) /* netscape 3 passes this */
 872         resource_id = (UINT)(-((INT)resource_id));
 873     TRACE("instance = %04x, id = %04x, buffer = %08x, "
 874           "length = %d\n", instance, (int)resource_id, (int) buffer, buflen);
 875
 876     /* Use bits 4 - 19 (incremented by 1) as resourceid, mask out
 877      * 20 - 31. */
 878     hrsrc = FindResourceW( instance, (LPCWSTR)(((resource_id>>4)&0xffff)+1),
 879                              RT_STRINGW );
 880     if (!hrsrc) return 0;
 881     hmem = LoadResource( instance, hrsrc );
 882     if (!hmem) return 0;
 883
 884     p = LockResource(hmem);
 885     string_num = resource_id & 0x000f;
 886     for (i = 0; i < string_num; i++)
 887         p += *p + 1;
 888
 889     TRACE("strlen = %d\n", (int)*p );
 890
 891     if (buffer == NULL) return *p;
 892     i = min(buflen - 1, *p);
 893     if (i > 0) {
 894         memcpy(buffer, p + 1, i * sizeof (WCHAR));
 895         buffer[i] = (WCHAR) 0;
 896     } else {
 897         if (buflen > 1) {
 898             buffer[0] = (WCHAR) 0;
 899             return 0;
 900         }
 901 #if 0
 902         WARN("Dont know why caller give buflen=%d *p=%d trying to obtain string '%s'\n", buflen, *p, p + 1);
 903 #endif
 904     }
 905
 906     TRACE("%s loaded !\n", debugstr_w(buffer));
 907     return i;
 908 }
 909
 910 /**********************************************************************
 911  *      LoadString32A   (USER32.375)
 912  */
 913 INT WINAPI LoadStringA( HINSTANCE instance, UINT resource_id,
 914                             LPSTR buffer, INT buflen )
 915 {
 916     INT    retval;
 917     INT    wbuflen;
 918     INT    abuflen;
 919     LPWSTR wbuf = NULL;
 920     LPSTR  abuf = NULL;
 921
 922     if ( buffer != NULL && buflen > 0 )
 923         *buffer = 0;
 924
 925     wbuflen = LoadStringW(instance,resource_id,NULL,0);
 926     if ( !wbuflen )
 927         return 0;
 928     wbuflen ++;
 929
 930     retval = 0;
 931     wbuf = HeapAlloc( GetProcessHeap(), 0, wbuflen * sizeof(WCHAR) );
 932     wbuflen = LoadStringW(instance,resource_id,wbuf,wbuflen);
 933     if ( wbuflen > 0 )
 934     {
 935         abuflen = WideCharToMultiByte(CP_ACP,0,wbuf,wbuflen,NULL,0,NULL,NULL);
 936         if ( abuflen > 0 )
 937         {
 938             if ( buffer == NULL || buflen == 0 )
 939                 retval = abuflen;
 940             else
 941             {
 942                 abuf = HeapAlloc( GetProcessHeap(), 0, abuflen * sizeof(CHAR) );
 943                 abuflen = WideCharToMultiByte(CP_ACP,0,wbuf,wbuflen,abuf,abuflen,NULL,NULL);
 944                 if ( abuflen > 0 )
 945                 {
 946                     abuflen = min(abuflen,buflen - 1);
 947                     memcpy( buffer, abuf, abuflen );
 948                     buffer[abuflen] = 0;
 949                     retval = abuflen;
 950                 }
 951                 HeapFree( GetProcessHeap(), 0, abuf );
 952             }
 953         }
 954     }
 955     HeapFree( GetProcessHeap(), 0, wbuf );
 956
 957     return retval;
 958 }
 959
 960 /* Messages...used by FormatMessage32* (KERNEL32.something)
 961  *
 962  * They can be specified either directly or using a message ID and
 963  * loading them from the resource.
 964  *
 965  * The resourcedata has following format:
 966  * start:
 967  * 0: DWORD nrofentries
 968  * nrofentries * subentry:
 969  *      0: DWORD firstentry
 970  *      4: DWORD lastentry
 971  *      8: DWORD offset from start to the stringentries
 972  *
 973  * (lastentry-firstentry) * stringentry:
 974  * 0: WORD len (0 marks end)
 975  * 2: WORD flags
 976  * 4: CHAR[len-4]
 977  *      (stringentry i of a subentry refers to the ID 'firstentry+i')
 978  *
 979  * Yes, ANSI strings in win32 resources. Go figure.
 980  */
 981
 982 /**********************************************************************
 983  *      LoadMessage32A          (internal)
 984  */
 985 INT WINAPI LoadMessageA( HMODULE instance, UINT id, WORD lang,
 986                       LPSTR buffer, INT buflen )
 987 {
 988     HGLOBAL     hmem;
 989     HRSRC       hrsrc;
 990     PMESSAGE_RESOURCE_DATA      mrd;
 991     PMESSAGE_RESOURCE_BLOCK     mrb;
 992     PMESSAGE_RESOURCE_ENTRY     mre;
 993     int         i,slen;
 994
 995     TRACE("instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD)instance, (DWORD)id, buffer, (DWORD)buflen);
 996
 997     /*FIXME: I am not sure about the '1' ... But I've only seen those entries*/
 998     hrsrc = FindResourceExW(instance,RT_MESSAGELISTW,(LPWSTR)1,lang);
 999     if (!hrsrc) return 0;
1000     hmem = LoadResource( instance, hrsrc );
1001     if (!hmem) return 0;
1002
1003     mrd = (PMESSAGE_RESOURCE_DATA)LockResource(hmem);
1004     mre = NULL;
1005     mrb = &(mrd->Blocks[0]);
1006     for (i=mrd->NumberOfBlocks;i--;) {
1007         if ((id>=mrb->LowId) && (id<=mrb->HighId)) {
1008             mre = (PMESSAGE_RESOURCE_ENTRY)(((char*)mrd)+mrb->OffsetToEntries);
1009             id  -= mrb->LowId;
1010             break;
1011         }
1012         mrb++;
1013     }
1014     if (!mre)
1015         return 0;
1016     for (i=id;i--;) {
1017         if (!mre->Length)
1018                 return 0;
1019         mre = (PMESSAGE_RESOURCE_ENTRY)(((char*)mre)+(mre->Length));
1020     }
1021     slen=mre->Length;
1022     TRACE("     - strlen=%d\n",slen);
1023     i = min(buflen - 1, slen);
1024     if (buffer == NULL)
1025         return slen;
1026     if (i>0) {
1027         lstrcpynA(buffer,(char*)mre->Text,i);
1028         buffer[i]=0;
1029     } else {
1030         if (buflen>1) {
1031             buffer[0]=0;
1032             return 0;
1033         }
1034     }
1035     if (buffer)
1036             TRACE("'%s' copied !\n", buffer);
1037     return i;
1038 }
1039
1040 /**********************************************************************
1041  *      LoadMessage32W  (internal)
1042  */
1043 INT WINAPI LoadMessageW( HMODULE instance, UINT id, WORD lang,
1044                       LPWSTR buffer, INT buflen )
1045 {
1046     INT retval;
1047     LPSTR buffer2 = NULL;
1048     if (buffer && buflen)
1049         buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen );
1050     retval = LoadMessageA(instance,id,lang,buffer2,buflen);
1051     if (buffer)
1052     {
1053         if (retval) {
1054             lstrcpynAtoW( buffer, buffer2, buflen );
1055             retval = lstrlenW( buffer );
1056         }
1057         HeapFree( GetProcessHeap(), 0, buffer2 );
1058     }
1059     return retval;
1060 }
1061
1062
1063 /**********************************************************************
1064  *      EnumResourceTypesA      (KERNEL32.90)
1065  */
1066 BOOL WINAPI EnumResourceTypesA( HMODULE hmodule,ENUMRESTYPEPROCA lpfun,
1067                                     LONG lParam)
1068 {
1069         /* FIXME: move WINE_MODREF stuff here */
1070     return PE_EnumResourceTypesA(hmodule,lpfun,lParam);
1071 }
1072
1073 /**********************************************************************
1074  *      EnumResourceTypesW      (KERNEL32.91)
1075  */
1076 BOOL WINAPI EnumResourceTypesW( HMODULE hmodule,ENUMRESTYPEPROCW lpfun,
1077                                     LONG lParam)
1078 {
1079         /* FIXME: move WINE_MODREF stuff here */
1080     return PE_EnumResourceTypesW(hmodule,lpfun,lParam);
1081 }
1082
1083 /**********************************************************************
1084  *      EnumResourceNamesA      (KERNEL32.88)
1085  */
1086 BOOL WINAPI EnumResourceNamesA( HMODULE hmodule, LPCSTR type,
1087                                     ENUMRESNAMEPROCA lpfun, LONG lParam )
1088 {
1089         /* FIXME: move WINE_MODREF stuff here */
1090     return PE_EnumResourceNamesA(hmodule,type,lpfun,lParam);
1091 }
1092 /**********************************************************************
1093  *      EnumResourceNamesW      (KERNEL32.89)
1094  */
1095 BOOL WINAPI EnumResourceNamesW( HMODULE hmodule, LPCWSTR type,
1096                                     ENUMRESNAMEPROCW lpfun, LONG lParam )
1097 {
1098         /* FIXME: move WINE_MODREF stuff here */
1099     return PE_EnumResourceNamesW(hmodule,type,lpfun,lParam);
1100 }
1101
1102 /**********************************************************************
1103  *      EnumResourceLanguagesA  (KERNEL32.86)
1104  */
1105 BOOL WINAPI EnumResourceLanguagesA( HMODULE hmodule, LPCSTR type,
1106                                         LPCSTR name, ENUMRESLANGPROCA lpfun,
1107                                         LONG lParam)
1108 {
1109         /* FIXME: move WINE_MODREF stuff here */
1110     return PE_EnumResourceLanguagesA(hmodule,type,name,lpfun,lParam);
1111 }
1112 /**********************************************************************
1113  *      EnumResourceLanguagesW  (KERNEL32.87)
1114  */
1115 BOOL WINAPI EnumResourceLanguagesW( HMODULE hmodule, LPCWSTR type,
1116                                         LPCWSTR name, ENUMRESLANGPROCW lpfun,
1117                                         LONG lParam)
1118 {
1119         /* FIXME: move WINE_MODREF stuff here */
1120     return PE_EnumResourceLanguagesW(hmodule,type,name,lpfun,lParam);
1121 }