loader/resource.c

   1 /*
   2  * Resources
   3  *
   4  * Copyright 1993 Robert J. Amstadt
   5  * Copyright 1995 Alexandre Julliard
   6  */
   7
   8 #include <stdio.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 "windows.h"
  16 #include "gdi.h"
  17 #include "global.h"
  18 #include "heap.h"
  19 #include "neexe.h"
  20 #include "task.h"
  21 #include "module.h"
  22 #include "resource.h"
  23 #include "debugstr.h"
  24 #include "debug.h"
  25 #include "libres.h"
  26
  27 extern WORD WINE_LanguageId;
  28
  29 /* error message when 16-bit resource function is called for Win32 module */
  30 static const char* NEWin32FailureString = "fails with Win32 module\n";
  31 /* error message when 32-bit resource function is called for Win16 module */
  32 static const char* PEWin16FailureString = "fails with Win16 module\n";
  33
  34 /**********************************************************************
  35  *          FindResource16    (KERNEL.60)
  36  */
  37 HRSRC16 WINAPI FindResource16( HMODULE16 hModule, SEGPTR name, SEGPTR type )
  38 {
  39     NE_MODULE *pModule;
  40
  41     hModule = MODULE_HANDLEtoHMODULE16( hModule );
  42
  43     if (HIWORD(name))  /* Check for '#xxx' name */
  44     {
  45         char *ptr = PTR_SEG_TO_LIN( name );
  46         if (ptr[0] == '#')
  47             if (!(name = (SEGPTR)atoi( ptr + 1 ))) {
  48               dprintf_warn(resource, "Incorrect resource name: %s\n", ptr);
  49               return 0;
  50             }
  51     }
  52
  53     if (HIWORD(type))  /* Check for '#xxx' type */
  54     {
  55         char *ptr = PTR_SEG_TO_LIN( type );
  56         if (ptr[0] == '#')
  57           if (!(type = (SEGPTR)atoi( ptr + 1 ))){
  58             dprintf_warn(resource, "Incorrect resource type: %s\n", ptr);
  59             return 0;
  60           }
  61     }
  62
  63     dprintf_info(resource, "FindResource16: module=%04x name=%s type=%s\n",
  64                  hModule, debugres(PTR_SEG_TO_LIN(name)),
  65                  debugres(PTR_SEG_TO_LIN(type)) );
  66
  67     if ((pModule = MODULE_GetPtr( hModule )))
  68     {
  69         if (!__winelib)
  70         {
  71             if (pModule->flags & NE_FFLAGS_WIN32)
  72                 fprintf(stderr,"FindResource16: %s", NEWin32FailureString);
  73             else
  74                 return NE_FindResource( hModule, type, name );
  75         }
  76         else return LIBRES_FindResource16( hModule,
  77                                            (LPCSTR)PTR_SEG_TO_LIN(name),
  78                                            (LPCSTR)PTR_SEG_TO_LIN(type) );
  79     }
  80     return 0;
  81 }
  82
  83
  84 /**********************************************************************
  85  *          FindResource32A    (KERNEL32.128)
  86  */
  87 HANDLE32 WINAPI FindResource32A( HINSTANCE32 hModule, LPCSTR name, LPCSTR type)
  88 {
  89     return FindResourceEx32A(hModule,name,type,WINE_LanguageId);
  90 }
  91
  92 /**********************************************************************
  93  *          FindResourceEx32A    (KERNEL32.129)
  94  */
  95 HANDLE32 WINAPI FindResourceEx32A( HINSTANCE32 hModule, LPCSTR name,
  96                                    LPCSTR type, WORD lang )
  97 {
  98     LPWSTR xname,xtype;
  99     HANDLE32 ret;
 100
 101     if (HIWORD((DWORD)name))
 102         xname = HEAP_strdupAtoW( GetProcessHeap(), 0, name );
 103     else
 104         xname = (LPWSTR)name;
 105     if (HIWORD((DWORD)type))
 106         xtype = HEAP_strdupAtoW( GetProcessHeap(), 0, type);
 107     else
 108         xtype = (LPWSTR)type;
 109     ret = FindResourceEx32W( hModule, xname, xtype, lang );
 110     if (HIWORD((DWORD)name)) HeapFree( GetProcessHeap(), 0, xname );
 111     if (HIWORD((DWORD)type)) HeapFree( GetProcessHeap(), 0, xtype );
 112     return ret;
 113 }
 114
 115
 116 /**********************************************************************
 117  *          FindResourceEx32W    (KERNEL32.130)
 118  */
 119 HRSRC32 WINAPI FindResourceEx32W( HINSTANCE32 hModule, LPCWSTR name,
 120                                   LPCWSTR type, WORD lang )
 121 {
 122     if (!__winelib)
 123     {
 124         NE_MODULE *pModule;
 125
 126         if (!hModule) hModule = GetTaskDS();
 127         hModule = MODULE_HANDLEtoHMODULE32( hModule );
 128         dprintf_info(resource, "FindResource32W: module=%08x "
 129                          "type=%s%p name=%s%p\n", hModule,
 130                          (HIWORD(type))? "" : "#", type,
 131                          (HIWORD(name))? "" : "#", name);
 132
 133         if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 134         if (!(pModule->flags & NE_FFLAGS_WIN32)) return 0;
 135         return PE_FindResourceEx32W(hModule,name,type,lang);
 136     }
 137     else return LIBRES_FindResource32( hModule, name, type );
 138 }
 139
 140 /**********************************************************************
 141  *          FindResource32W    (KERNEL32.131)
 142  */
 143 HRSRC32 WINAPI FindResource32W(HINSTANCE32 hModule, LPCWSTR name, LPCWSTR type)
 144 {
 145     return FindResourceEx32W(hModule,name,type,WINE_LanguageId);
 146 }
 147
 148
 149 /**********************************************************************
 150  *          LoadResource16    (KERNEL.61)
 151  */
 152 HGLOBAL16 WINAPI LoadResource16( HMODULE16 hModule, HRSRC16 hRsrc )
 153 {
 154     NE_MODULE *pModule;
 155
 156     hModule = MODULE_HANDLEtoHMODULE16( hModule );
 157     dprintf_info(resource, "LoadResource16: module=%04x res=%04x\n",
 158                      hModule, hRsrc );
 159     if (!hRsrc) return 0;
 160     if ((pModule = MODULE_GetPtr( hModule )))
 161     {
 162         if (!__winelib)
 163         {
 164             if (pModule->flags & NE_FFLAGS_WIN32)
 165                 fprintf(stderr,"LoadResource16: %s", NEWin32FailureString);
 166             else
 167                 return NE_LoadResource( hModule, hRsrc );
 168         }
 169         else return LIBRES_LoadResource( hModule, hRsrc );
 170     }
 171     return 0;
 172 }
 173
 174 /**********************************************************************
 175  *          LoadResource32    (KERNEL32.370)
 176  */
 177 HGLOBAL32 WINAPI LoadResource32( HINSTANCE32 hModule, HRSRC32 hRsrc )
 178 {
 179     if (!__winelib)
 180     {
 181         NE_MODULE *pModule;
 182
 183         if (!hModule) hModule = GetTaskDS(); /* FIXME: see FindResource32W */
 184         hModule = MODULE_HANDLEtoHMODULE32( hModule );
 185         dprintf_info(resource, "LoadResource32: module=%04x res=%04x\n",
 186                          hModule, hRsrc );
 187         if (!hRsrc) return 0;
 188
 189         if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 190         if (!(pModule->flags & NE_FFLAGS_WIN32))
 191         {
 192             fprintf(stderr,"LoadResource32: %s", PEWin16FailureString );
 193             return 0;  /* FIXME? */
 194         }
 195         return PE_LoadResource32(hModule,hRsrc);
 196     }
 197     else return LIBRES_LoadResource( hModule, hRsrc );
 198 }
 199
 200
 201 /**********************************************************************
 202  *          LockResource    (KERNEL.62)
 203  */
 204 /* 16-bit version */
 205 SEGPTR WINAPI WIN16_LockResource16(HGLOBAL16 handle)
 206 {
 207     HMODULE16 hModule;
 208     NE_MODULE *pModule;
 209
 210     dprintf_info(resource, "LockResource: handle=%04x\n", handle );
 211     if (!handle) return (SEGPTR)0;
 212     hModule = MODULE_HANDLEtoHMODULE16( handle );
 213     if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 214     if (pModule->flags & NE_FFLAGS_WIN32)
 215     {
 216         fprintf(stderr,"LockResource16: %s", NEWin32FailureString);
 217         return 0;
 218     }
 219     return NE_LockResource( hModule, handle );
 220 }
 221
 222 /* Winelib 16-bit version */
 223 LPVOID WINAPI LockResource16( HGLOBAL16 handle )
 224 {
 225     if (!__winelib)
 226     {
 227         HMODULE16 hModule;
 228         NE_MODULE *pModule;
 229
 230         dprintf_info(resource, "LockResource: handle=%04x\n", handle );
 231         if (!handle) return NULL;
 232         hModule = MODULE_HANDLEtoHMODULE16( handle );
 233         if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 234         if (pModule->flags & NE_FFLAGS_WIN32)
 235         {
 236             fprintf(stderr,"LockResource16: %s", NEWin32FailureString);
 237             return 0;
 238         }
 239         return (LPSTR)PTR_SEG_TO_LIN( NE_LockResource( hModule, handle ) );
 240     }
 241     else return LIBRES_LockResource( handle );
 242 }
 243
 244
 245 /**********************************************************************
 246  *          LockResource32    (KERNEL32.384)
 247  */
 248 LPVOID WINAPI LockResource32( HGLOBAL32 handle )
 249 {
 250     return (LPVOID)handle;
 251 }
 252
 253
 254 /**********************************************************************
 255  *          FreeResource16    (KERNEL.63)
 256  */
 257 BOOL16 WINAPI FreeResource16( HGLOBAL16 handle )
 258 {
 259     if (!__winelib)
 260     {
 261         HMODULE16 hModule;
 262         NE_MODULE *pModule;
 263
 264         dprintf_info(resource, "FreeResource16: handle=%04x\n", handle );
 265         if (!handle) return FALSE;
 266         hModule = MODULE_HANDLEtoHMODULE16( handle );
 267         if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 268         if (pModule->flags & NE_FFLAGS_WIN32)
 269         {
 270             fprintf(stderr,"FreeResource16: %s", NEWin32FailureString);
 271             return 0;
 272         }
 273         return NE_FreeResource( hModule, handle );
 274     }
 275     else return LIBRES_FreeResource( handle );
 276 }
 277
 278 /**********************************************************************
 279  *          FreeResource32    (KERNEL32.145)
 280  */
 281 BOOL32 WINAPI FreeResource32( HGLOBAL32 handle )
 282 {
 283     /* no longer used in Win32 */
 284     return TRUE;
 285 }
 286
 287
 288 /**********************************************************************
 289  *          AccessResource16    (KERNEL.64)
 290  */
 291 INT16 WINAPI AccessResource16( HINSTANCE16 hModule, HRSRC16 hRsrc )
 292 {
 293     NE_MODULE *pModule;
 294
 295     hModule = MODULE_HANDLEtoHMODULE16( hModule );
 296     dprintf_info(resource, "AccessResource16: module=%04x res=%04x\n",
 297                      hModule, hRsrc );
 298     if (!hRsrc) return 0;
 299     if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 300     if (!__winelib)
 301     {
 302         if (pModule->flags & NE_FFLAGS_WIN32)
 303         {
 304             fprintf(stderr,"AccessResource16: %s", NEWin32FailureString);
 305             return 0;
 306         }
 307         return NE_AccessResource( hModule, hRsrc );
 308     }
 309     else return LIBRES_AccessResource( hModule, hRsrc );
 310 }
 311
 312
 313 /**********************************************************************
 314  *          AccessResource32    (KERNEL32.64)
 315  */
 316 INT32 WINAPI AccessResource32( HINSTANCE32 hModule, HRSRC32 hRsrc )
 317 {
 318     hModule = MODULE_HANDLEtoHMODULE32( hModule );
 319     dprintf_info(resource, "AccessResource: module=%04x res=%04x\n",
 320                      hModule, hRsrc );
 321     if (!hRsrc) return 0;
 322     fprintf(stderr,"AccessResource32: not implemented\n");
 323     return 0;
 324 }
 325
 326
 327 /**********************************************************************
 328  *          SizeofResource16    (KERNEL.65)
 329  */
 330 DWORD WINAPI SizeofResource16( HMODULE16 hModule, HRSRC16 hRsrc )
 331 {
 332     NE_MODULE *pModule;
 333
 334     hModule = MODULE_HANDLEtoHMODULE16( hModule );
 335     dprintf_info(resource, "SizeofResource16: module=%04x res=%04x\n",
 336                      hModule, hRsrc );
 337     if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 338     if (!__winelib)
 339     {
 340         if (pModule->flags & NE_FFLAGS_WIN32)
 341         {
 342             fprintf(stderr,"SizeOfResource16: %s", NEWin32FailureString);
 343             return 0;
 344         }
 345         return NE_SizeofResource( hModule, hRsrc );
 346     }
 347     else return LIBRES_SizeofResource( hModule, hRsrc );
 348 }
 349
 350
 351 /**********************************************************************
 352  *          SizeofResource32    (KERNEL32.522)
 353  */
 354 DWORD WINAPI SizeofResource32( HINSTANCE32 hModule, HRSRC32 hRsrc )
 355 {
 356     hModule = MODULE_HANDLEtoHMODULE32( hModule );
 357     dprintf_info(resource, "SizeofResource32: module=%04x res=%04x\n",
 358                      hModule, hRsrc );
 359     if (!__winelib) return PE_SizeofResource32(hModule,hRsrc);
 360     else
 361     {
 362         fprintf(stderr,"SizeofResource32: not implemented\n");
 363         return 0;
 364     }
 365 }
 366
 367
 368 /**********************************************************************
 369  *          AllocResource16    (KERNEL.66)
 370  */
 371 HGLOBAL16 WINAPI AllocResource16( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
 372 {
 373     NE_MODULE *pModule;
 374
 375     hModule = MODULE_HANDLEtoHMODULE16( hModule );
 376     dprintf_info(resource, "AllocResource: module=%04x res=%04x size=%ld\n",
 377                      hModule, hRsrc, size );
 378     if (!hRsrc) return 0;
 379     if (!(pModule = MODULE_GetPtr( hModule ))) return 0;
 380     if (!__winelib)
 381     {
 382         if (pModule->flags & NE_FFLAGS_WIN32)
 383         {
 384             fprintf(stderr,"AllocResource16: %s", NEWin32FailureString);
 385             return 0;
 386         }
 387         return NE_AllocResource( hModule, hRsrc, size );
 388     }
 389     else return LIBRES_AllocResource( hModule, hRsrc, size );
 390 }
 391
 392 /**********************************************************************
 393  *      DirectResAlloc    (KERNEL.168)
 394  *
 395  * Check Schulman, p. 232 for details
 396  */
 397 HGLOBAL16 WINAPI DirectResAlloc( HINSTANCE16 hInstance, WORD wType,
 398                                  UINT16 wSize )
 399 {
 400     dprintf_info(resource,"DirectResAlloc(%04x,%04x,%04x)\n",
 401                      hInstance, wType, wSize );
 402     hInstance = MODULE_HANDLEtoHMODULE16(hInstance);
 403     if(!hInstance)return 0;
 404     if(wType != 0x10)   /* 0x10 is the only observed value, passed from
 405                            CreateCursorIndirect. */
 406         fprintf(stderr, "DirectResAlloc: wType = %x\n", wType);
 407     return GLOBAL_Alloc(GMEM_MOVEABLE, wSize, hInstance, FALSE, FALSE, FALSE);
 408 }
 409
 410
 411 /**********************************************************************
 412  *                      LoadAccelerators16      [USER.177]
 413  */
 414 HACCEL16 WINAPI LoadAccelerators16(HINSTANCE16 instance, SEGPTR lpTableName)
 415 {
 416     HRSRC16     hRsrc;
 417
 418     if (HIWORD(lpTableName))
 419         dprintf_info(accel, "LoadAccelerators: %04x '%s'\n",
 420                       instance, (char *)PTR_SEG_TO_LIN( lpTableName ) );
 421     else
 422         dprintf_info(accel, "LoadAccelerators: %04x %04x\n",
 423                        instance, LOWORD(lpTableName) );
 424
 425     if (!(hRsrc = FindResource16( instance, lpTableName, RT_ACCELERATOR )))
 426       return 0;
 427     return LoadResource16(instance,hRsrc);
 428 }
 429
 430 /**********************************************************************
 431  *                      LoadAccelerators32W     [USER.177]
 432  * The image layout seems to look like this (not 100% sure):
 433  * 00:  BYTE    type            type of accelerator
 434  * 01:  BYTE    pad             (to WORD boundary)
 435  * 02:  WORD    event
 436  * 04:  WORD    IDval
 437  * 06:  WORD    pad             (to DWORD boundary)
 438  */
 439 HACCEL32 WINAPI LoadAccelerators32W(HINSTANCE32 instance,LPCWSTR lpTableName)
 440 {
 441     HRSRC32 hRsrc;
 442
 443     if (HIWORD(lpTableName))
 444         dprintf_info(accel, "LoadAccelerators: %04x '%s'\n",
 445                       instance, (char *)( lpTableName ) );
 446     else
 447         dprintf_info(accel, "LoadAccelerators: %04x %04x\n",
 448                        instance, LOWORD(lpTableName) );
 449
 450     if (!(hRsrc = FindResource32W( instance, lpTableName,
 451                 (LPCWSTR)RT_ACCELERATOR )))
 452       return 0;
 453     return LoadResource32( instance, hRsrc );
 454 }
 455
 456 HACCEL32 WINAPI LoadAccelerators32A(HINSTANCE32 instance,LPCSTR lpTableName)
 457 {
 458         LPWSTR   uni;
 459         HACCEL32 result;
 460         if (HIWORD(lpTableName))
 461                 uni = HEAP_strdupAtoW( GetProcessHeap(), 0, lpTableName );
 462         else
 463                 uni = (LPWSTR)lpTableName;
 464         result = LoadAccelerators32W(instance,uni);
 465         if (HIWORD(uni)) HeapFree( GetProcessHeap(), 0, uni);
 466         return result;
 467 }
 468
 469 /**********************************************************************
 470  *             CopyAcceleratorTable32A   (USER32.58)
 471  */
 472 INT32 WINAPI CopyAcceleratorTable32A(HACCEL32 src, LPACCEL32 dst, INT32 entries)
 473 {
 474   fprintf(stderr,"CopyAcceleratorTable32A: not implemented: %d\n", entries);
 475   return 0;
 476 }
 477
 478 /**********************************************************************
 479  *             CopyAcceleratorTable32W   (USER32.59)
 480  */
 481 INT32 WINAPI CopyAcceleratorTable32W(HACCEL32 src, LPACCEL32 dst, INT32 entries)
 482 {
 483   fprintf(stderr,"CopyAcceleratorTable32W: not implemented: %d\n", entries);
 484   return 0;
 485 }
 486
 487 /**********************************************************************
 488  *             DestroyAcceleratorTable   (USER32.130)
 489  */
 490 BOOL32 WINAPI DestroyAcceleratorTable( HACCEL32 handle )
 491 {
 492   fprintf(stderr,"DestroyAcceleratorTable: not implemented\n");
 493   return TRUE;
 494 }
 495
 496 /**********************************************************************
 497  *                                      LoadString16
 498  */
 499 INT16 WINAPI LoadString16( HINSTANCE16 instance, UINT16 resource_id,
 500                            LPSTR buffer, INT16 buflen )
 501 {
 502     HGLOBAL16 hmem;
 503     HRSRC16 hrsrc;
 504     unsigned char *p;
 505     int string_num;
 506     int i;
 507
 508     dprintf_info(resource,"LoadString: inst=%04x id=%04x buff=%08x len=%d\n",
 509                      instance, resource_id, (int) buffer, buflen);
 510
 511     hrsrc = FindResource16( instance, (SEGPTR)((resource_id>>4)+1), RT_STRING );
 512     if (!hrsrc) return 0;
 513     hmem = LoadResource16( instance, hrsrc );
 514     if (!hmem) return 0;
 515
 516     p = LockResource16(hmem);
 517     string_num = resource_id & 0x000f;
 518     for (i = 0; i < string_num; i++)
 519         p += *p + 1;
 520
 521     dprintf_info(resource, "strlen = %d\n", (int)*p );
 522
 523     i = MIN(buflen - 1, *p);
 524     if (buffer == NULL)
 525         return i;
 526     if (i > 0) {
 527         memcpy(buffer, p + 1, i);
 528         buffer[i] = '\0';
 529     } else {
 530         if (buflen > 1) {
 531             buffer[0] = '\0';
 532             return 0;
 533         }
 534         fprintf(stderr,"LoadString // I dont know why , but caller give buflen=%d *p=%d !\n", buflen, *p);
 535         fprintf(stderr,"LoadString // and try to obtain string '%s'\n", p + 1);
 536     }
 537     FreeResource16( hmem );
 538
 539     dprintf_info(resource,"LoadString // '%s' copied !\n", buffer);
 540     return i;
 541 }
 542
 543 /**********************************************************************
 544  *      LoadString32W           (USER32.375)
 545  */
 546 INT32 WINAPI LoadString32W( HINSTANCE32 instance, UINT32 resource_id,
 547                             LPWSTR buffer, INT32 buflen )
 548 {
 549     HGLOBAL32 hmem;
 550     HRSRC32 hrsrc;
 551     WCHAR *p;
 552     int string_num;
 553     int i;
 554
 555     if (HIWORD(resource_id)==0xFFFF) /* netscape 3 passes this */
 556         resource_id = (UINT32)(-((INT32)resource_id));
 557     dprintf_info(resource, "LoadString: instance = %04x, id = %04x, buffer = %08x, "
 558            "length = %d\n", instance, (int)resource_id, (int) buffer, buflen);
 559
 560     hrsrc = FindResource32W( instance, (LPCWSTR)((resource_id>>4)+1),
 561                 (LPCWSTR)RT_STRING );
 562     if (!hrsrc) return 0;
 563     hmem = LoadResource32( instance, hrsrc );
 564     if (!hmem) return 0;
 565
 566     p = LockResource32(hmem);
 567     string_num = resource_id & 0x000f;
 568     for (i = 0; i < string_num; i++)
 569         p += *p + 1;
 570
 571     dprintf_info(resource, "strlen = %d\n", (int)*p );
 572
 573     i = MIN(buflen - 1, *p);
 574     if (buffer == NULL)
 575         return i;
 576     if (i > 0) {
 577         memcpy(buffer, p + 1, i * sizeof (WCHAR));
 578         buffer[i] = (WCHAR) 0;
 579     } else {
 580         if (buflen > 1) {
 581             buffer[0] = (WCHAR) 0;
 582             return 0;
 583         }
 584 #if 0
 585         fprintf(stderr,"LoadString // I dont know why , but caller give buflen=%d *p=%d !\n", buflen, *p);
 586         fprintf(stderr,"LoadString // and try to obtain string '%s'\n", p + 1);
 587 #endif
 588     }
 589 #if 0
 590     dprintf_info(resource,"LoadString // '%s' copied !\n", buffer);
 591 #endif
 592     return i;
 593 }
 594
 595 /**********************************************************************
 596  *      LoadString32A   (USER32.374)
 597  */
 598 INT32 WINAPI LoadString32A( HINSTANCE32 instance, UINT32 resource_id,
 599                             LPSTR buffer, INT32 buflen )
 600 {
 601     INT32 retval;
 602     LPWSTR buffer2 = NULL;
 603     if (buffer && buflen)
 604         buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen * 2 );
 605     retval = LoadString32W(instance,resource_id,buffer2,buflen);
 606
 607     if (buffer2)
 608     {
 609         if (retval) {
 610             lstrcpynWtoA( buffer, buffer2, buflen );
 611             retval = lstrlen32A( buffer );
 612         }
 613         HeapFree( GetProcessHeap(), 0, buffer2 );
 614     }
 615     return retval;
 616 }
 617
 618 /* Messages...used by FormatMessage32* (KERNEL32.something)
 619  *
 620  * They can be specified either directly or using a message ID and
 621  * loading them from the resource.
 622  *
 623  * The resourcedata has following format:
 624  * start:
 625  * 0: DWORD nrofentries
 626  * nrofentries * subentry:
 627  *      0: DWORD firstentry
 628  *      4: DWORD lastentry
 629  *      8: DWORD offset from start to the stringentries
 630  *
 631  * (lastentry-firstentry) * stringentry:
 632  * 0: WORD len (0 marks end)
 633  * 2: WORD unknown (flags?)
 634  * 4: CHAR[len-4]
 635  *      (stringentry i of a subentry refers to the ID 'firstentry+i')
 636  *
 637  * Yes, ANSI strings in win32 resources. Go figure.
 638  */
 639
 640 /**********************************************************************
 641  *      LoadMessage32A          (internal)
 642  */
 643 INT32 LoadMessage32A( HINSTANCE32 instance, UINT32 id, WORD lang,
 644                       LPSTR buffer, INT32 buflen )
 645 {
 646     HGLOBAL32   hmem;
 647     HRSRC32     hrsrc;
 648     BYTE        *p;
 649     int         nrofentries,i,slen;
 650     struct      _subentry {
 651         DWORD   firstentry;
 652         DWORD   lastentry;
 653         DWORD   offset;
 654     } *se;
 655     struct      _stringentry {
 656         WORD    len;
 657         WORD    unknown;
 658         CHAR    str[1];
 659     } *stre;
 660
 661     dprintf_info(resource, "LoadMessage: instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD)instance, (DWORD)id, buffer, (DWORD)buflen);
 662
 663     /*FIXME: I am not sure about the '1' ... But I've only seen those entries*/
 664     hrsrc = FindResourceEx32W(instance,(LPWSTR)1,(LPCWSTR)RT_MESSAGELIST,lang);
 665     if (!hrsrc) return 0;
 666     hmem = LoadResource32( instance, hrsrc );
 667     if (!hmem) return 0;
 668
 669     p = LockResource32(hmem);
 670     nrofentries = *(DWORD*)p;
 671     stre = NULL;
 672     se = (struct _subentry*)(p+4);
 673     for (i=nrofentries;i--;) {
 674         if ((id>=se->firstentry) && (id<=se->lastentry)) {
 675             stre = (struct _stringentry*)(p+se->offset);
 676             id  -= se->firstentry;
 677             break;
 678         }
 679         se++;
 680     }
 681     if (!stre)
 682         return 0;
 683     for (i=id;i--;) {
 684         if (!(slen=stre->len))
 685                 return 0;
 686         stre = (struct _stringentry*)(((char*)stre)+slen);
 687     }
 688     slen=stre->len;
 689     dprintf_info(resource,"     - strlen=%d\n",slen);
 690     i = MIN(buflen - 1, slen);
 691     if (buffer == NULL)
 692         return slen; /* different to LoadString */
 693     if (i>0) {
 694         lstrcpyn32A(buffer,stre->str,i);
 695         buffer[i]=0;
 696     } else {
 697         if (buflen>1) {
 698             buffer[0]=0;
 699             return 0;
 700         }
 701     }
 702     if (buffer)
 703             dprintf_info(resource,"LoadMessage // '%s' copied !\n", buffer);
 704     return i;
 705 }
 706
 707 /**********************************************************************
 708  *      LoadMessage32W  (internal)
 709  */
 710 INT32 LoadMessage32W( HINSTANCE32 instance, UINT32 id, WORD lang,
 711                       LPWSTR buffer, INT32 buflen )
 712 {
 713     INT32 retval;
 714     LPSTR buffer2 = NULL;
 715     if (buffer && buflen)
 716         buffer2 = HeapAlloc( GetProcessHeap(), 0, buflen );
 717     retval = LoadMessage32A(instance,id,lang,buffer2,buflen);
 718     if (buffer)
 719     {
 720         if (retval) {
 721             lstrcpynAtoW( buffer, buffer2, buflen );
 722             retval = lstrlen32W( buffer );
 723         }
 724         HeapFree( GetProcessHeap(), 0, buffer2 );
 725     }
 726     return retval;
 727 }
 728
 729
 730 /**********************************************************************
 731  *      SetResourceHandler      (KERNEL.43)
 732  */
 733 FARPROC16 WINAPI SetResourceHandler( HMODULE16 hModule, SEGPTR s,
 734                                      FARPROC16 resourceHandler )
 735 {
 736     NE_MODULE *pModule;
 737
 738     hModule = GetExePtr( hModule );
 739
 740     dprintf_info(resource, "SetResourceHandler: module=%04x type=%s\n",
 741                  hModule, debugres(PTR_SEG_TO_LIN(s)) );
 742
 743     if ((pModule = MODULE_GetPtr( hModule )))
 744     {
 745         if (pModule->flags & NE_FFLAGS_WIN32)
 746             fprintf(stderr,"SetResourceHandler: %s\n", NEWin32FailureString);
 747         else if (pModule->res_table)
 748             return NE_SetResourceHandler( hModule, s, resourceHandler );
 749     }
 750     return NULL;
 751 }
 752
 753
 754 /**********************************************************************
 755  *      EnumResourceTypesA      (KERNEL32.90)
 756  */
 757 BOOL32 WINAPI EnumResourceTypes32A( HMODULE32 hmodule,ENUMRESTYPEPROC32A lpfun,
 758                                     LONG lParam)
 759 {
 760     return PE_EnumResourceTypes32A(hmodule,lpfun,lParam);
 761 }
 762
 763 /**********************************************************************
 764  *      EnumResourceTypesW      (KERNEL32.91)
 765  */
 766 BOOL32 WINAPI EnumResourceTypes32W( HMODULE32 hmodule,ENUMRESTYPEPROC32W lpfun,
 767                                     LONG lParam)
 768 {
 769     return PE_EnumResourceTypes32W(hmodule,lpfun,lParam);
 770 }
 771
 772 /**********************************************************************
 773  *      EnumResourceNamesA      (KERNEL32.88)
 774  */
 775 BOOL32 WINAPI EnumResourceNames32A( HMODULE32 hmodule, LPCSTR type,
 776                                     ENUMRESNAMEPROC32A lpfun, LONG lParam )
 777 {
 778     return PE_EnumResourceNames32A(hmodule,type,lpfun,lParam);
 779 }
 780 /**********************************************************************
 781  *      EnumResourceNamesW      (KERNEL32.89)
 782  */
 783 BOOL32 WINAPI EnumResourceNames32W( HMODULE32 hmodule, LPCWSTR type,
 784                                     ENUMRESNAMEPROC32W lpfun, LONG lParam )
 785 {
 786     return PE_EnumResourceNames32W(hmodule,type,lpfun,lParam);
 787 }
 788
 789 /**********************************************************************
 790  *      EnumResourceLanguagesA  (KERNEL32.86)
 791  */
 792 BOOL32 WINAPI EnumResourceLanguages32A( HMODULE32 hmodule, LPCSTR type,
 793                                         LPCSTR name, ENUMRESLANGPROC32A lpfun,
 794                                         LONG lParam)
 795 {
 796     return PE_EnumResourceLanguages32A(hmodule,type,name,lpfun,lParam);
 797 }
 798 /**********************************************************************
 799  *      EnumResourceLanguagesW  (KERNEL32.87)
 800  */
 801 BOOL32 WINAPI EnumResourceLanguages32W( HMODULE32 hmodule, LPCWSTR type,
 802                                         LPCWSTR name, ENUMRESLANGPROC32W lpfun,
 803                                         LONG lParam)
 804 {
 805     return PE_EnumResourceLanguages32W(hmodule,type,name,lpfun,lParam);
 806 }