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