4 * Copyright 1993 Robert J. Amstadt
5 * Copyright 1995 Alexandre Julliard
11 #include <sys/types.h>
27 extern WORD WINE_LanguageId
;
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";
34 /**********************************************************************
35 * FindResource16 (KERNEL.60)
37 HRSRC16 WINAPI
FindResource16( HMODULE16 hModule
, SEGPTR name
, SEGPTR type
)
41 hModule
= MODULE_HANDLEtoHMODULE16( hModule
);
43 if (HIWORD(name
)) /* Check for '#xxx' name */
45 char *ptr
= PTR_SEG_TO_LIN( name
);
47 if (!(name
= (SEGPTR
)atoi( ptr
+ 1 ))) {
48 dprintf_warn(resource
, "Incorrect resource name: %s\n", ptr
);
53 if (HIWORD(type
)) /* Check for '#xxx' type */
55 char *ptr
= PTR_SEG_TO_LIN( type
);
57 if (!(type
= (SEGPTR
)atoi( ptr
+ 1 ))){
58 dprintf_warn(resource
, "Incorrect resource type: %s\n", ptr
);
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
)) );
67 if ((pModule
= MODULE_GetPtr( hModule
)))
71 if (pModule
->flags
& NE_FFLAGS_WIN32
)
72 fprintf(stderr
,"FindResource16: %s", NEWin32FailureString
);
74 return NE_FindResource( hModule
, type
, name
);
76 else return LIBRES_FindResource16( hModule
,
77 (LPCSTR
)PTR_SEG_TO_LIN(name
),
78 (LPCSTR
)PTR_SEG_TO_LIN(type
) );
84 /**********************************************************************
85 * FindResource32A (KERNEL32.128)
87 HANDLE32 WINAPI
FindResource32A( HINSTANCE32 hModule
, LPCSTR name
, LPCSTR type
)
89 return FindResourceEx32A(hModule
,name
,type
,WINE_LanguageId
);
92 /**********************************************************************
93 * FindResourceEx32A (KERNEL32.129)
95 HANDLE32 WINAPI
FindResourceEx32A( HINSTANCE32 hModule
, LPCSTR name
,
96 LPCSTR type
, WORD lang
)
101 if (HIWORD((DWORD
)name
))
102 xname
= HEAP_strdupAtoW( GetProcessHeap(), 0, name
);
104 xname
= (LPWSTR
)name
;
105 if (HIWORD((DWORD
)type
))
106 xtype
= HEAP_strdupAtoW( GetProcessHeap(), 0, type
);
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
);
116 /**********************************************************************
117 * FindResourceEx32W (KERNEL32.130)
119 HRSRC32 WINAPI
FindResourceEx32W( HINSTANCE32 hModule
, LPCWSTR name
,
120 LPCWSTR type
, WORD lang
)
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
);
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
);
137 else return LIBRES_FindResource32( hModule
, name
, type
);
140 /**********************************************************************
141 * FindResource32W (KERNEL32.131)
143 HRSRC32 WINAPI
FindResource32W(HINSTANCE32 hModule
, LPCWSTR name
, LPCWSTR type
)
145 return FindResourceEx32W(hModule
,name
,type
,WINE_LanguageId
);
149 /**********************************************************************
150 * LoadResource16 (KERNEL.61)
152 HGLOBAL16 WINAPI
LoadResource16( HMODULE16 hModule
, HRSRC16 hRsrc
)
156 hModule
= MODULE_HANDLEtoHMODULE16( hModule
);
157 dprintf_info(resource
, "LoadResource16: module=%04x res=%04x\n",
159 if (!hRsrc
) return 0;
160 if ((pModule
= MODULE_GetPtr( hModule
)))
164 if (pModule
->flags
& NE_FFLAGS_WIN32
)
165 fprintf(stderr
,"LoadResource16: %s", NEWin32FailureString
);
167 return NE_LoadResource( hModule
, hRsrc
);
169 else return LIBRES_LoadResource( hModule
, hRsrc
);
174 /**********************************************************************
175 * LoadResource32 (KERNEL32.370)
177 HGLOBAL32 WINAPI
LoadResource32( HINSTANCE32 hModule
, HRSRC32 hRsrc
)
183 if (!hModule
) hModule
= GetTaskDS(); /* FIXME: see FindResource32W */
184 hModule
= MODULE_HANDLEtoHMODULE32( hModule
);
185 dprintf_info(resource
, "LoadResource32: module=%04x res=%04x\n",
187 if (!hRsrc
) return 0;
189 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
190 if (!(pModule
->flags
& NE_FFLAGS_WIN32
))
192 fprintf(stderr
,"LoadResource32: %s", PEWin16FailureString
);
193 return 0; /* FIXME? */
195 return PE_LoadResource32(hModule
,hRsrc
);
197 else return LIBRES_LoadResource( hModule
, hRsrc
);
201 /**********************************************************************
202 * LockResource (KERNEL.62)
205 SEGPTR WINAPI
WIN16_LockResource16(HGLOBAL16 handle
)
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
)
216 fprintf(stderr
,"LockResource16: %s", NEWin32FailureString
);
219 return NE_LockResource( hModule
, handle
);
222 /* Winelib 16-bit version */
223 LPVOID WINAPI
LockResource16( HGLOBAL16 handle
)
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
)
236 fprintf(stderr
,"LockResource16: %s", NEWin32FailureString
);
239 return (LPSTR
)PTR_SEG_TO_LIN( NE_LockResource( hModule
, handle
) );
241 else return LIBRES_LockResource( handle
);
245 /**********************************************************************
246 * LockResource32 (KERNEL32.384)
248 LPVOID WINAPI
LockResource32( HGLOBAL32 handle
)
250 return (LPVOID
)handle
;
254 /**********************************************************************
255 * FreeResource16 (KERNEL.63)
257 BOOL16 WINAPI
FreeResource16( HGLOBAL16 handle
)
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
)
270 fprintf(stderr
,"FreeResource16: %s", NEWin32FailureString
);
273 return NE_FreeResource( hModule
, handle
);
275 else return LIBRES_FreeResource( handle
);
278 /**********************************************************************
279 * FreeResource32 (KERNEL32.145)
281 BOOL32 WINAPI
FreeResource32( HGLOBAL32 handle
)
283 /* no longer used in Win32 */
288 /**********************************************************************
289 * AccessResource16 (KERNEL.64)
291 INT16 WINAPI
AccessResource16( HINSTANCE16 hModule
, HRSRC16 hRsrc
)
295 hModule
= MODULE_HANDLEtoHMODULE16( hModule
);
296 dprintf_info(resource
, "AccessResource16: module=%04x res=%04x\n",
298 if (!hRsrc
) return 0;
299 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
302 if (pModule
->flags
& NE_FFLAGS_WIN32
)
304 fprintf(stderr
,"AccessResource16: %s", NEWin32FailureString
);
307 return NE_AccessResource( hModule
, hRsrc
);
309 else return LIBRES_AccessResource( hModule
, hRsrc
);
313 /**********************************************************************
314 * AccessResource32 (KERNEL32.64)
316 INT32 WINAPI
AccessResource32( HINSTANCE32 hModule
, HRSRC32 hRsrc
)
318 hModule
= MODULE_HANDLEtoHMODULE32( hModule
);
319 dprintf_info(resource
, "AccessResource: module=%04x res=%04x\n",
321 if (!hRsrc
) return 0;
322 fprintf(stderr
,"AccessResource32: not implemented\n");
327 /**********************************************************************
328 * SizeofResource16 (KERNEL.65)
330 DWORD WINAPI
SizeofResource16( HMODULE16 hModule
, HRSRC16 hRsrc
)
334 hModule
= MODULE_HANDLEtoHMODULE16( hModule
);
335 dprintf_info(resource
, "SizeofResource16: module=%04x res=%04x\n",
337 if (!(pModule
= MODULE_GetPtr( hModule
))) return 0;
340 if (pModule
->flags
& NE_FFLAGS_WIN32
)
342 fprintf(stderr
,"SizeOfResource16: %s", NEWin32FailureString
);
345 return NE_SizeofResource( hModule
, hRsrc
);
347 else return LIBRES_SizeofResource( hModule
, hRsrc
);
351 /**********************************************************************
352 * SizeofResource32 (KERNEL32.522)
354 DWORD WINAPI
SizeofResource32( HINSTANCE32 hModule
, HRSRC32 hRsrc
)
356 hModule
= MODULE_HANDLEtoHMODULE32( hModule
);
357 dprintf_info(resource
, "SizeofResource32: module=%04x res=%04x\n",
359 if (!__winelib
) return PE_SizeofResource32(hModule
,hRsrc
);
362 fprintf(stderr
,"SizeofResource32: not implemented\n");
368 /**********************************************************************
369 * AllocResource16 (KERNEL.66)
371 HGLOBAL16 WINAPI
AllocResource16( HMODULE16 hModule
, HRSRC16 hRsrc
, DWORD size
)
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;
382 if (pModule
->flags
& NE_FFLAGS_WIN32
)
384 fprintf(stderr
,"AllocResource16: %s", NEWin32FailureString
);
387 return NE_AllocResource( hModule
, hRsrc
, size
);
389 else return LIBRES_AllocResource( hModule
, hRsrc
, size
);
392 /**********************************************************************
393 * DirectResAlloc (KERNEL.168)
395 * Check Schulman, p. 232 for details
397 HGLOBAL16 WINAPI
DirectResAlloc( HINSTANCE16 hInstance
, WORD wType
,
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
);
411 /**********************************************************************
412 * LoadAccelerators16 [USER.177]
414 HACCEL16 WINAPI
LoadAccelerators16(HINSTANCE16 instance
, SEGPTR lpTableName
)
418 if (HIWORD(lpTableName
))
419 dprintf_info(accel
, "LoadAccelerators: %04x '%s'\n",
420 instance
, (char *)PTR_SEG_TO_LIN( lpTableName
) );
422 dprintf_info(accel
, "LoadAccelerators: %04x %04x\n",
423 instance
, LOWORD(lpTableName
) );
425 if (!(hRsrc
= FindResource16( instance
, lpTableName
, RT_ACCELERATOR
)))
427 return LoadResource16(instance
,hRsrc
);
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)
437 * 06: WORD pad (to DWORD boundary)
439 HACCEL32 WINAPI
LoadAccelerators32W(HINSTANCE32 instance
,LPCWSTR lpTableName
)
443 if (HIWORD(lpTableName
))
444 dprintf_info(accel
, "LoadAccelerators: %04x '%s'\n",
445 instance
, (char *)( lpTableName
) );
447 dprintf_info(accel
, "LoadAccelerators: %04x %04x\n",
448 instance
, LOWORD(lpTableName
) );
450 if (!(hRsrc
= FindResource32W( instance
, lpTableName
,
451 (LPCWSTR
)RT_ACCELERATOR
)))
453 return LoadResource32( instance
, hRsrc
);
456 HACCEL32 WINAPI
LoadAccelerators32A(HINSTANCE32 instance
,LPCSTR lpTableName
)
460 if (HIWORD(lpTableName
))
461 uni
= HEAP_strdupAtoW( GetProcessHeap(), 0, lpTableName
);
463 uni
= (LPWSTR
)lpTableName
;
464 result
= LoadAccelerators32W(instance
,uni
);
465 if (HIWORD(uni
)) HeapFree( GetProcessHeap(), 0, uni
);
469 /**********************************************************************
470 * CopyAcceleratorTable32A (USER32.58)
472 INT32 WINAPI
CopyAcceleratorTable32A(HACCEL32 src
, LPACCEL32 dst
, INT32 entries
)
474 fprintf(stderr
,"CopyAcceleratorTable32A: not implemented: %d\n", entries
);
478 /**********************************************************************
479 * CopyAcceleratorTable32W (USER32.59)
481 INT32 WINAPI
CopyAcceleratorTable32W(HACCEL32 src
, LPACCEL32 dst
, INT32 entries
)
483 fprintf(stderr
,"CopyAcceleratorTable32W: not implemented: %d\n", entries
);
487 /**********************************************************************
488 * DestroyAcceleratorTable (USER32.130)
490 BOOL32 WINAPI
DestroyAcceleratorTable( HACCEL32 handle
)
492 fprintf(stderr
,"DestroyAcceleratorTable: not implemented\n");
496 /**********************************************************************
499 INT16 WINAPI
LoadString16( HINSTANCE16 instance
, UINT16 resource_id
,
500 LPSTR buffer
, INT16 buflen
)
508 dprintf_info(resource
,"LoadString: inst=%04x id=%04x buff=%08x len=%d\n",
509 instance
, resource_id
, (int) buffer
, buflen
);
511 hrsrc
= FindResource16( instance
, (SEGPTR
)((resource_id
>>4)+1), RT_STRING
);
512 if (!hrsrc
) return 0;
513 hmem
= LoadResource16( instance
, hrsrc
);
516 p
= LockResource16(hmem
);
517 string_num
= resource_id
& 0x000f;
518 for (i
= 0; i
< string_num
; i
++)
521 dprintf_info(resource
, "strlen = %d\n", (int)*p
);
523 i
= MIN(buflen
- 1, *p
);
527 memcpy(buffer
, p
+ 1, i
);
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);
537 FreeResource16( hmem
);
539 dprintf_info(resource
,"LoadString // '%s' copied !\n", buffer
);
543 /**********************************************************************
544 * LoadString32W (USER32.375)
546 INT32 WINAPI
LoadString32W( HINSTANCE32 instance
, UINT32 resource_id
,
547 LPWSTR buffer
, INT32 buflen
)
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
);
560 hrsrc
= FindResource32W( instance
, (LPCWSTR
)((resource_id
>>4)+1),
561 (LPCWSTR
)RT_STRING
);
562 if (!hrsrc
) return 0;
563 hmem
= LoadResource32( instance
, hrsrc
);
566 p
= LockResource32(hmem
);
567 string_num
= resource_id
& 0x000f;
568 for (i
= 0; i
< string_num
; i
++)
571 dprintf_info(resource
, "strlen = %d\n", (int)*p
);
573 i
= MIN(buflen
- 1, *p
);
577 memcpy(buffer
, p
+ 1, i
* sizeof (WCHAR
));
578 buffer
[i
] = (WCHAR
) 0;
581 buffer
[0] = (WCHAR
) 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);
590 dprintf_info(resource
,"LoadString // '%s' copied !\n", buffer
);
595 /**********************************************************************
596 * LoadString32A (USER32.374)
598 INT32 WINAPI
LoadString32A( HINSTANCE32 instance
, UINT32 resource_id
,
599 LPSTR buffer
, INT32 buflen
)
602 LPWSTR buffer2
= NULL
;
603 if (buffer
&& buflen
)
604 buffer2
= HeapAlloc( GetProcessHeap(), 0, buflen
* 2 );
605 retval
= LoadString32W(instance
,resource_id
,buffer2
,buflen
);
610 lstrcpynWtoA( buffer
, buffer2
, buflen
);
611 retval
= lstrlen32A( buffer
);
613 HeapFree( GetProcessHeap(), 0, buffer2
);
618 /* Messages...used by FormatMessage32* (KERNEL32.something)
620 * They can be specified either directly or using a message ID and
621 * loading them from the resource.
623 * The resourcedata has following format:
625 * 0: DWORD nrofentries
626 * nrofentries * subentry:
627 * 0: DWORD firstentry
629 * 8: DWORD offset from start to the stringentries
631 * (lastentry-firstentry) * stringentry:
632 * 0: WORD len (0 marks end)
633 * 2: WORD unknown (flags?)
635 * (stringentry i of a subentry refers to the ID 'firstentry+i')
637 * Yes, ANSI strings in win32 resources. Go figure.
640 /**********************************************************************
641 * LoadMessage32A (internal)
643 INT32
LoadMessage32A( HINSTANCE32 instance
, UINT32 id
, WORD lang
,
644 LPSTR buffer
, INT32 buflen
)
649 int nrofentries
,i
,slen
;
655 struct _stringentry
{
661 dprintf_info(resource
, "LoadMessage: instance = %08lx, id = %08lx, buffer = %p, length = %ld\n", (DWORD
)instance
, (DWORD
)id
, buffer
, (DWORD
)buflen
);
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
);
669 p
= LockResource32(hmem
);
670 nrofentries
= *(DWORD
*)p
;
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
;
684 if (!(slen
=stre
->len
))
686 stre
= (struct _stringentry
*)(((char*)stre
)+slen
);
689 dprintf_info(resource
," - strlen=%d\n",slen
);
690 i
= MIN(buflen
- 1, slen
);
692 return slen
; /* different to LoadString */
694 lstrcpyn32A(buffer
,stre
->str
,i
);
703 dprintf_info(resource
,"LoadMessage // '%s' copied !\n", buffer
);
707 /**********************************************************************
708 * LoadMessage32W (internal)
710 INT32
LoadMessage32W( HINSTANCE32 instance
, UINT32 id
, WORD lang
,
711 LPWSTR buffer
, INT32 buflen
)
714 LPSTR buffer2
= NULL
;
715 if (buffer
&& buflen
)
716 buffer2
= HeapAlloc( GetProcessHeap(), 0, buflen
);
717 retval
= LoadMessage32A(instance
,id
,lang
,buffer2
,buflen
);
721 lstrcpynAtoW( buffer
, buffer2
, buflen
);
722 retval
= lstrlen32W( buffer
);
724 HeapFree( GetProcessHeap(), 0, buffer2
);
730 /**********************************************************************
731 * SetResourceHandler (KERNEL.43)
733 FARPROC16 WINAPI
SetResourceHandler( HMODULE16 hModule
, SEGPTR s
,
734 FARPROC16 resourceHandler
)
738 hModule
= GetExePtr( hModule
);
740 dprintf_info(resource
, "SetResourceHandler: module=%04x type=%s\n",
741 hModule
, debugres(PTR_SEG_TO_LIN(s
)) );
743 if ((pModule
= MODULE_GetPtr( hModule
)))
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
);
754 /**********************************************************************
755 * EnumResourceTypesA (KERNEL32.90)
757 BOOL32 WINAPI
EnumResourceTypes32A( HMODULE32 hmodule
,ENUMRESTYPEPROC32A lpfun
,
760 return PE_EnumResourceTypes32A(hmodule
,lpfun
,lParam
);
763 /**********************************************************************
764 * EnumResourceTypesW (KERNEL32.91)
766 BOOL32 WINAPI
EnumResourceTypes32W( HMODULE32 hmodule
,ENUMRESTYPEPROC32W lpfun
,
769 return PE_EnumResourceTypes32W(hmodule
,lpfun
,lParam
);
772 /**********************************************************************
773 * EnumResourceNamesA (KERNEL32.88)
775 BOOL32 WINAPI
EnumResourceNames32A( HMODULE32 hmodule
, LPCSTR type
,
776 ENUMRESNAMEPROC32A lpfun
, LONG lParam
)
778 return PE_EnumResourceNames32A(hmodule
,type
,lpfun
,lParam
);
780 /**********************************************************************
781 * EnumResourceNamesW (KERNEL32.89)
783 BOOL32 WINAPI
EnumResourceNames32W( HMODULE32 hmodule
, LPCWSTR type
,
784 ENUMRESNAMEPROC32W lpfun
, LONG lParam
)
786 return PE_EnumResourceNames32W(hmodule
,type
,lpfun
,lParam
);
789 /**********************************************************************
790 * EnumResourceLanguagesA (KERNEL32.86)
792 BOOL32 WINAPI
EnumResourceLanguages32A( HMODULE32 hmodule
, LPCSTR type
,
793 LPCSTR name
, ENUMRESLANGPROC32A lpfun
,
796 return PE_EnumResourceLanguages32A(hmodule
,type
,name
,lpfun
,lParam
);
798 /**********************************************************************
799 * EnumResourceLanguagesW (KERNEL32.87)
801 BOOL32 WINAPI
EnumResourceLanguages32W( HMODULE32 hmodule
, LPCWSTR type
,
802 LPCWSTR name
, ENUMRESLANGPROC32W lpfun
,
805 return PE_EnumResourceLanguages32W(hmodule
,type
,name
,lpfun
,lParam
);