Assorted spelling fixes.
[wine] / dlls / kernel32 / resource16.c
1 /*
2  * 16-bit resource functions
3  *
4  * Copyright 1993 Robert J. Amstadt
5  * Copyright 1997 Alex Korobka
6  * Copyright 1998 Ulrich Weigand
7  * Copyright 1995, 2003 Alexandre Julliard
8  *
9  * This library is free software; you can redistribute it and/or
10  * modify it under the terms of the GNU Lesser General Public
11  * License as published by the Free Software Foundation; either
12  * version 2.1 of the License, or (at your option) any later version.
13  *
14  * This library is distributed in the hope that it will be useful,
15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
17  * Lesser General Public License for more details.
18  *
19  * You should have received a copy of the GNU Lesser General Public
20  * License along with this library; if not, write to the Free Software
21  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22  */
23
24 #include "config.h"
25 #include "wine/port.h"
26
27 #include <stdarg.h>
28 #include <stdio.h>
29 #include <stdlib.h>
30 #include <string.h>
31 #include <sys/types.h>
32
33 #include "windef.h"
34 #include "winbase.h"
35 #include "wownt32.h"
36 #include "wine/winbase16.h"
37 #include "wine/winuser16.h"
38 #include "wine/unicode.h"
39 #include "kernel16_private.h"
40 #include "wine/debug.h"
41
42 WINE_DEFAULT_DEBUG_CHANNEL(resource);
43
44 /* handle conversions */
45 #define HRSRC_32(h16)   ((HRSRC)(ULONG_PTR)(h16))
46 #define HGLOBAL_32(h16) ((HGLOBAL)(ULONG_PTR)(h16))
47
48 static inline NE_MODULE *get_module( HMODULE16 mod )
49 {
50     if (!mod) mod = TASK_GetCurrent()->hModule;
51     return NE_GetPtr( mod );
52 }
53
54 #define HRSRC_MAP_BLOCKSIZE 16
55
56 typedef struct _HRSRC_ELEM
57 {
58     HRSRC hRsrc;
59     WORD  type;
60 } HRSRC_ELEM;
61
62 typedef struct _HRSRC_MAP
63 {
64     int nAlloc;
65     int nUsed;
66     HRSRC_ELEM *elem;
67 } HRSRC_MAP;
68
69
70 /**********************************************************************
71  *          MapHRsrc32To16
72  */
73 static HRSRC16 MapHRsrc32To16( NE_MODULE *pModule, HRSRC hRsrc32, WORD type )
74 {
75     HRSRC_MAP *map = pModule->rsrc32_map;
76     HRSRC_ELEM *newElem;
77     int i;
78
79     /* On first call, initialize HRSRC map */
80     if ( !map )
81     {
82         if ( !(map = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(HRSRC_MAP) ) ) )
83         {
84             ERR("Cannot allocate HRSRC map\n" );
85             return 0;
86         }
87         pModule->rsrc32_map = map;
88     }
89
90     /* Check whether HRSRC32 already in map */
91     for ( i = 0; i < map->nUsed; i++ )
92         if ( map->elem[i].hRsrc == hRsrc32 )
93             return (HRSRC16)(i + 1);
94
95     /* If no space left, grow table */
96     if ( map->nUsed == map->nAlloc )
97     {
98
99         if (map->elem)
100             newElem = HeapReAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
101                     map->elem, (map->nAlloc + HRSRC_MAP_BLOCKSIZE) * sizeof(HRSRC_ELEM) );
102         else
103             newElem = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY,
104                     (map->nAlloc + HRSRC_MAP_BLOCKSIZE) * sizeof(HRSRC_ELEM) );
105
106         if ( !newElem )
107         {
108             ERR("Cannot grow HRSRC map\n" );
109             return 0;
110         }
111         map->elem = newElem;
112         map->nAlloc += HRSRC_MAP_BLOCKSIZE;
113     }
114
115     /* Add HRSRC32 to table */
116     map->elem[map->nUsed].hRsrc = hRsrc32;
117     map->elem[map->nUsed].type  = type;
118     map->nUsed++;
119
120     return (HRSRC16)map->nUsed;
121 }
122
123 /**********************************************************************
124  *          MapHRsrc16To32
125  */
126 static HRSRC MapHRsrc16To32( NE_MODULE *pModule, HRSRC16 hRsrc16 )
127 {
128     HRSRC_MAP *map = pModule->rsrc32_map;
129     if ( !map || !hRsrc16 || hRsrc16 > map->nUsed ) return 0;
130
131     return map->elem[hRsrc16-1].hRsrc;
132 }
133
134 /**********************************************************************
135  *          MapHRsrc16ToType
136  */
137 static WORD MapHRsrc16ToType( NE_MODULE *pModule, HRSRC16 hRsrc16 )
138 {
139     HRSRC_MAP *map = pModule->rsrc32_map;
140     if ( !map || !hRsrc16 || hRsrc16 > map->nUsed ) return 0;
141
142     return map->elem[hRsrc16-1].type;
143 }
144
145
146 /**********************************************************************
147  *          get_res_name
148  *
149  * Convert a resource name from '#xxx' form to numerical id.
150  */
151 static inline LPCSTR get_res_name( LPCSTR name )
152 {
153     if (HIWORD(name) && name[0] == '#') name = MAKEINTRESOURCEA( atoi( name + 1 ) );
154     return name;
155 }
156
157
158 /**********************************************************************
159  *          next_typeinfo
160  */
161 static inline NE_TYPEINFO *next_typeinfo( NE_TYPEINFO *info )
162 {
163     return (NE_TYPEINFO *)((char*)(info + 1) + info->count * sizeof(NE_NAMEINFO));
164 }
165
166
167 /**********************************************************************
168  *          get_default_res_handler
169  */
170 static inline FARPROC16 get_default_res_handler(void)
171 {
172     static FARPROC16 handler;
173
174     if (!handler) handler = GetProcAddress16( GetModuleHandle16("KERNEL"), "DefResourceHandler" );
175     return handler;
176 }
177
178
179 /***********************************************************************
180  *           NE_FindNameTableId
181  *
182  * Find the type and resource id from their names.
183  * Return value is MAKELONG( typeId, resId ), or 0 if not found.
184  */
185 static DWORD NE_FindNameTableId( NE_MODULE *pModule, LPCSTR typeId, LPCSTR resId )
186 {
187     NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->ne_rsrctab + 2);
188     NE_NAMEINFO *pNameInfo;
189     HGLOBAL16 handle;
190     WORD *p;
191     DWORD ret = 0;
192     int count;
193
194     for (; pTypeInfo->type_id != 0;
195            pTypeInfo = (NE_TYPEINFO *)((char*)(pTypeInfo+1) +
196                                         pTypeInfo->count * sizeof(NE_NAMEINFO)))
197     {
198         if (pTypeInfo->type_id != 0x800f) continue;
199         pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
200         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
201         {
202             TRACE("NameTable entry: type=%04x id=%04x\n",
203                               pTypeInfo->type_id, pNameInfo->id );
204             handle = LoadResource16( pModule->self,
205                                      (HRSRC16)((char *)pNameInfo - (char *)pModule) );
206             for(p = LockResource16(handle); p && *p; p = (WORD *)((char*)p+*p))
207             {
208                 TRACE("  type=%04x '%s' id=%04x '%s'\n",
209                                   p[1], (char *)(p+3), p[2],
210                                   (char *)(p+3)+strlen((char *)(p+3))+1 );
211                 /* Check for correct type */
212
213                 if (p[1] & 0x8000)
214                 {
215                     if (!HIWORD(typeId)) continue;
216                     if (strcasecmp( typeId, (char *)(p + 3) )) continue;
217                 }
218                 else if (HIWORD(typeId) || (((DWORD)typeId & ~0x8000)!= p[1]))
219                   continue;
220
221                 /* Now check for the id */
222
223                 if (p[2] & 0x8000)
224                 {
225                     if (!HIWORD(resId)) continue;
226                     if (strcasecmp( resId, (char*)(p+3)+strlen((char*)(p+3))+1 )) continue;
227
228                 }
229                 else if (HIWORD(resId) || ((LOWORD(resId) & ~0x8000) != p[2]))
230                   continue;
231
232                 /* If we get here, we've found the entry */
233
234                 TRACE("  Found!\n" );
235                 ret = MAKELONG( p[1], p[2] );
236                 break;
237             }
238             FreeResource16( handle );
239             if (ret) return ret;
240         }
241     }
242     return 0;
243 }
244
245
246 /***********************************************************************
247  *           NE_FindTypeSection
248  *
249  * Find header struct for a particular resource type.
250  */
251 static NE_TYPEINFO *NE_FindTypeSection( LPBYTE pResTab, NE_TYPEINFO *pTypeInfo, LPCSTR typeId )
252 {
253     /* start from pTypeInfo */
254
255     if (HIWORD(typeId) != 0)  /* Named type */
256     {
257         LPCSTR str = typeId;
258         BYTE len = strlen( str );
259         while (pTypeInfo->type_id)
260         {
261             if (!(pTypeInfo->type_id & 0x8000))
262             {
263                 BYTE *p = pResTab + pTypeInfo->type_id;
264                 if ((*p == len) && !strncasecmp( (char*)p+1, str, len ))
265                 {
266                     TRACE("  Found type '%s'\n", str );
267                     return pTypeInfo;
268                 }
269             }
270             TRACE("  Skipping type %04x\n", pTypeInfo->type_id );
271             pTypeInfo = next_typeinfo(pTypeInfo);
272         }
273     }
274     else  /* Numeric type id */
275     {
276         WORD id = LOWORD(typeId) | 0x8000;
277         while (pTypeInfo->type_id)
278         {
279             if (pTypeInfo->type_id == id)
280             {
281                 TRACE("  Found type %04x\n", id );
282                 return pTypeInfo;
283             }
284             TRACE("  Skipping type %04x\n", pTypeInfo->type_id );
285             pTypeInfo = next_typeinfo(pTypeInfo);
286         }
287     }
288     return NULL;
289 }
290
291
292 /***********************************************************************
293  *           NE_FindResourceFromType
294  *
295  * Find a resource once the type info structure has been found.
296  */
297 static NE_NAMEINFO *NE_FindResourceFromType( LPBYTE pResTab, NE_TYPEINFO *pTypeInfo, LPCSTR resId )
298 {
299     BYTE *p;
300     int count;
301     NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
302
303     if (HIWORD(resId) != 0)  /* Named resource */
304     {
305         LPCSTR str = resId;
306         BYTE len = strlen( str );
307         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
308         {
309             if (pNameInfo->id & 0x8000) continue;
310             p = pResTab + pNameInfo->id;
311             if ((*p == len) && !strncasecmp( (char*)p+1, str, len ))
312                 return pNameInfo;
313         }
314     }
315     else  /* Numeric resource id */
316     {
317         WORD id = LOWORD(resId) | 0x8000;
318         for (count = pTypeInfo->count; count > 0; count--, pNameInfo++)
319             if (pNameInfo->id == id) return pNameInfo;
320     }
321     return NULL;
322 }
323
324
325 /***********************************************************************
326  *           DefResourceHandler (KERNEL.456)
327  *
328  * This is the default LoadProc() function.
329  */
330 HGLOBAL16 WINAPI NE_DefResourceHandler( HGLOBAL16 hMemObj, HMODULE16 hModule,
331                                         HRSRC16 hRsrc )
332 {
333     HGLOBAL16 handle;
334     WORD sizeShift;
335     NE_NAMEINFO* pNameInfo;
336     NE_MODULE* pModule = NE_GetPtr( hModule );
337
338     if (!pModule) return 0;
339
340     sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab);
341     pNameInfo = (NE_NAMEINFO *)((char *)pModule + hRsrc);
342
343     if ( hMemObj )
344         handle = GlobalReAlloc16( hMemObj, pNameInfo->length << sizeShift, 0 );
345     else
346         handle = AllocResource16( hModule, hRsrc, 0 );
347
348     if (handle)
349     {
350         if (!NE_READ_DATA( pModule, GlobalLock16( handle ),
351                            (int)pNameInfo->offset << sizeShift,
352                            (int)pNameInfo->length << sizeShift ))
353         {
354             GlobalFree16( handle );
355             handle = 0;
356         }
357     }
358     return handle;
359 }
360
361
362 /**********************************************************************
363  *      SetResourceHandler      (KERNEL.67)
364  */
365 FARPROC16 WINAPI SetResourceHandler16( HMODULE16 hModule, LPCSTR typeId, FARPROC16 resourceHandler )
366 {
367     LPBYTE pResTab;
368     NE_TYPEINFO *pTypeInfo;
369     FARPROC16 prevHandler = NULL;
370     NE_MODULE *pModule = NE_GetPtr( hModule );
371
372     if (!pModule || !pModule->ne_rsrctab) return NULL;
373
374     pResTab = (LPBYTE)pModule + pModule->ne_rsrctab;
375     pTypeInfo = (NE_TYPEINFO *)(pResTab + 2);
376
377     TRACE("module=%04x type=%s\n", hModule, debugstr_a(typeId) );
378
379     for (;;)
380     {
381         if (!(pTypeInfo = NE_FindTypeSection( pResTab, pTypeInfo, typeId )))
382             break;
383         memcpy_unaligned( &prevHandler, &pTypeInfo->resloader, sizeof(FARPROC16) );
384         memcpy_unaligned( &pTypeInfo->resloader, &resourceHandler, sizeof(FARPROC16) );
385         pTypeInfo = next_typeinfo(pTypeInfo);
386     }
387     if (!prevHandler) prevHandler = get_default_res_handler();
388     return prevHandler;
389 }
390
391 static inline DWORD get_dword(LPCVOID *p)
392 {
393     DWORD ret = *(const DWORD *)*p;
394     *p = (const DWORD *)*p + 1;
395     return ret;
396 }
397
398 static inline void put_dword(LPVOID *p, DWORD d)
399 {
400     *(DWORD*)*p = d;
401     *p = (DWORD *)*p + 1;
402 }
403
404 static inline WORD get_word(LPCVOID *p)
405 {
406     WORD ret = *(const WORD *)*p;
407     *p = (const WORD *)*p + 1;
408     return ret;
409 }
410
411 static inline void put_word(LPVOID *p, WORD w)
412 {
413     *(WORD*)*p = w;
414     *p = (WORD *)*p + 1;
415 }
416
417 static inline BYTE get_byte(LPCVOID *p)
418 {
419     BYTE ret = *(const BYTE *)*p;
420     *p = (const BYTE *)*p + 1;
421     return ret;
422 }
423
424 static inline void put_byte(LPVOID *p, BYTE b)
425 {
426     *(BYTE *)*p = b;
427     *p = (BYTE *)*p + 1;
428 }
429
430 /* convert a resource name */
431 static void convert_name( LPVOID *dst, LPCVOID *src )
432 {
433     int len;
434     switch (*(const WORD *)*src)
435     {
436     case 0x0000:
437         get_word( src );
438         put_byte( dst, 0 );
439         break;
440     case 0xffff:
441         get_word( src );
442         put_byte( dst, 0xff );
443         put_word( dst, get_word(src) );
444         break;
445     default:
446         len = WideCharToMultiByte( CP_ACP, 0, *src, -1, *dst, 0x7fffffff, NULL,NULL );
447         *dst = (char *)*dst + len;
448         *src = (LPCWSTR)*src + strlenW( *src ) + 1;
449         break;
450     }
451 }
452
453 /**********************************************************************
454  *          ConvertDialog32To16   (KERNEL.615)
455  */
456 VOID WINAPI ConvertDialog32To16( LPCVOID dialog32, DWORD size, LPVOID dialog16 )
457 {
458     WORD nbItems, data, dialogEx;
459     DWORD style;
460
461     style = get_dword( &dialog32 );
462     put_dword( &dialog16, style );
463     dialogEx = (style == 0xffff0001);  /* DIALOGEX resource */
464     if (dialogEx)
465     {
466         put_dword( &dialog16, get_dword( &dialog32 ) );  /* helpID */
467         put_dword( &dialog16, get_dword( &dialog32 ) );  /* exStyle */
468         style = get_dword( &dialog32 );
469         put_dword( &dialog16, style );                   /* style */
470     }
471     else
472         dialog32 = (const DWORD *)dialog32 + 1; /* exStyle ignored in 16-bit standard dialog */
473
474     nbItems = get_word( &dialog32 );
475     put_byte( &dialog16, nbItems );
476     put_word( &dialog16, get_word( &dialog32 ) ); /* x */
477     put_word( &dialog16, get_word( &dialog32 ) ); /* y */
478     put_word( &dialog16, get_word( &dialog32 ) ); /* cx */
479     put_word( &dialog16, get_word( &dialog32 ) ); /* cy */
480
481     /* Transfer menu name */
482     convert_name( &dialog16, &dialog32 );
483
484     /* Transfer class name */
485     convert_name( &dialog16, &dialog32 );
486
487     /* Transfer window caption */
488     WideCharToMultiByte( CP_ACP, 0, dialog32, -1, dialog16, 0x7fffffff, NULL, NULL );
489     dialog16 = (LPSTR)dialog16 + strlen( dialog16 ) + 1;
490     dialog32 = (LPCWSTR)dialog32 + strlenW( dialog32 ) + 1;
491
492     /* Transfer font info */
493     if (style & DS_SETFONT)
494     {
495         put_word( &dialog16, get_word( &dialog32 ) );  /* pointSize */
496         if (dialogEx)
497         {
498             put_word( &dialog16, get_word( &dialog32 ) ); /* weight */
499             put_word( &dialog16, get_word( &dialog32 ) ); /* italic */
500         }
501         WideCharToMultiByte( CP_ACP, 0, dialog32, -1, dialog16, 0x7fffffff, NULL, NULL );  /* faceName */
502         dialog16 = (LPSTR)dialog16 + strlen( dialog16 ) + 1;
503         dialog32 = (LPCWSTR)dialog32 + strlenW( dialog32 ) + 1;
504     }
505
506     /* Transfer dialog items */
507     while (nbItems)
508     {
509         /* align on DWORD boundary (32-bit only) */
510         dialog32 = (LPCVOID)(((UINT_PTR)dialog32 + 3) & ~3);
511
512         if (dialogEx)
513         {
514             put_dword( &dialog16, get_dword( &dialog32 ) ); /* helpID */
515             put_dword( &dialog16, get_dword( &dialog32 ) ); /* exStyle */
516             put_dword( &dialog16, get_dword( &dialog32 ) ); /* style */
517         }
518         else
519         {
520             style = get_dword( &dialog32 );          /* save style */
521             dialog32 = (const DWORD *)dialog32 + 1;  /* ignore exStyle */
522         }
523
524         put_word( &dialog16, get_word( &dialog32 ) ); /* x */
525         put_word( &dialog16, get_word( &dialog32 ) ); /* y */
526         put_word( &dialog16, get_word( &dialog32 ) ); /* cx */
527         put_word( &dialog16, get_word( &dialog32 ) ); /* cy */
528
529         if (dialogEx)
530             put_dword( &dialog16, get_dword( &dialog32 ) ); /* ID */
531         else
532         {
533             put_word( &dialog16, get_word( &dialog32 ) ); /* ID */
534             put_dword( &dialog16, style );  /* style from above */
535         }
536
537         /* Transfer class name */
538         switch (*(const WORD *)dialog32)
539         {
540         case 0x0000:
541             get_word( &dialog32 );
542             put_byte( &dialog16, 0 );
543             break;
544         case 0xffff:
545             get_word( &dialog32 );
546             put_byte( &dialog16, get_word( &dialog32 ) );
547             break;
548         default:
549             WideCharToMultiByte( CP_ACP, 0, dialog32, -1, dialog16, 0x7fffffff, NULL, NULL );
550             dialog16 = (LPSTR)dialog16 + strlen( dialog16 ) + 1;
551             dialog32 = (LPCWSTR)dialog32 + strlenW( dialog32 ) + 1;
552             break;
553         }
554
555         /* Transfer window name */
556         convert_name( &dialog16, &dialog32 );
557
558         /* Transfer data */
559         data = get_word( &dialog32 );
560         if (dialogEx)
561             put_word(&dialog16, data);
562         else
563             put_byte(&dialog16,(BYTE)data);
564
565         if (data)
566         {
567             memcpy( dialog16, dialog32, data );
568             dialog16 = (BYTE *)dialog16 + data;
569             dialog32 = (const BYTE *)dialog32 + data;
570         }
571
572         /* Next item */
573         nbItems--;
574     }
575 }
576
577
578 /**********************************************************************
579  *          GetDialog32Size   (KERNEL.618)
580  */
581 WORD WINAPI GetDialog32Size16( LPCVOID dialog32 )
582 {
583     LPCVOID p = dialog32;
584     WORD nbItems, data, dialogEx;
585     DWORD style;
586
587     style = get_dword(&p);
588     dialogEx = (style == 0xffff0001);  /* DIALOGEX resource */
589     if (dialogEx)
590     {
591         p = (const DWORD *)p + 1; /* helpID */
592         p = (const DWORD *)p + 1; /* exStyle */
593         style = get_dword(&p); /* style */
594     }
595     else
596         p = (const DWORD *)p + 1; /* exStyle */
597
598     nbItems = get_word(&p);
599     p = (const DWORD *)p + 1; /* x */
600     p = (const DWORD *)p + 1; /* y */
601     p = (const DWORD *)p + 1; /* cx */
602     p = (const DWORD *)p + 1; /* cy */
603
604     /* Skip menu name */
605     switch (*(const DWORD *)p)
606     {
607     case 0x0000:  p = (const DWORD *)p + 1; break;
608     case 0xffff:  p = (const DWORD *)p + 2; break;
609     default:      p = (LPCWSTR)p + strlenW( p ) + 1; break;
610     }
611
612     /* Skip class name */
613     switch (*(const DWORD *)p)
614     {
615     case 0x0000:  p = (const DWORD *)p + 1; break;
616     case 0xffff:  p = (const DWORD *)p + 2; break;
617     default:      p = (LPCWSTR)p + strlenW( p ) + 1; break;
618     }
619
620     /* Skip window caption */
621     p = (LPCWSTR)p + strlenW( p ) + 1;
622
623     /* Skip font info */
624     if (style & DS_SETFONT)
625     {
626         p = (const DWORD *)p + 1;  /* pointSize */
627         if (dialogEx)
628         {
629             p = (const DWORD *)p + 1; /* weight */
630             p = (const DWORD *)p + 1; /* italic */
631         }
632         p = (LPCWSTR)p + strlenW( p ) + 1;  /* faceName */
633     }
634
635     /* Skip dialog items */
636     while (nbItems)
637     {
638         /* align on DWORD boundary */
639         p = (LPCVOID)(((UINT_PTR)p + 3) & ~3);
640
641         if (dialogEx)
642         {
643             p = (const DWORD *)p + 1; /* helpID */
644             p = (const DWORD *)p + 1; /* exStyle */
645             p = (const DWORD *)p + 1; /* style */
646         }
647         else
648         {
649             p = (const DWORD *)p + 1; /* style */
650             p = (const DWORD *)p + 1; /* exStyle */
651         }
652
653         p = (const DWORD *)p + 1; /* x */
654         p = (const DWORD *)p + 1; /* y */
655         p = (const DWORD *)p + 1; /* cx */
656         p = (const DWORD *)p + 1; /* cy */
657
658         if (dialogEx)
659             p = (const DWORD *)p + 1; /* ID */
660         else
661             p = (const DWORD *)p + 1; /* ID */
662
663         /* Skip class name */
664         switch (*(const DWORD *)p)
665         {
666         case 0x0000:  p = (const DWORD *)p + 1; break;
667         case 0xffff:  p = (const DWORD *)p + 2; break;
668         default:      p = (LPCWSTR)p + strlenW( p ) + 1; break;
669         }
670
671         /* Skip window name */
672         switch (*(const DWORD *)p)
673         {
674         case 0x0000:  p = (const DWORD *)p + 1; break;
675         case 0xffff:  p = (const DWORD *)p + 2; break;
676         default:      p = (LPCWSTR)p + strlenW( p ) + 1; break;
677         }
678
679         /* Skip data */
680         data = get_word(&p);
681         p = (const BYTE *)p + data;
682
683         /* Next item */
684         nbItems--;
685     }
686
687     return (WORD)((LPCSTR)p - (LPCSTR)dialog32);
688 }
689
690
691 /**********************************************************************
692  *          ConvertMenu32To16   (KERNEL.616)
693  */
694 VOID WINAPI ConvertMenu32To16( LPCVOID menu32, DWORD size, LPVOID menu16 )
695 {
696     WORD version, headersize, flags, level = 1;
697
698     version = get_word( &menu32 );
699     headersize = get_word( &menu32 );
700     put_word( &menu16, version );
701     put_word( &menu16, headersize );
702     if ( headersize )
703     {
704         memcpy( menu16, menu32, headersize );
705         menu16 = (BYTE *)menu16 + headersize;
706         menu32 = (const BYTE *)menu32 + headersize;
707     }
708
709     while ( level )
710         if ( version == 0 )  /* standard */
711         {
712             flags = get_word( &menu32 );
713             put_word( &menu16, flags );
714             if ( !(flags & MF_POPUP) )
715                 put_word( &menu16, get_word( &menu32 ) );  /* ID */
716             else
717                 level++;
718
719             WideCharToMultiByte( CP_ACP, 0, menu32, -1, menu16, 0x7fffffff, NULL, NULL );
720             menu16 = (LPSTR)menu16 + strlen( menu16 ) + 1;
721             menu32 = (LPCWSTR)menu32 + strlenW( menu32 ) + 1;
722
723             if ( flags & MF_END )
724                 level--;
725         }
726         else  /* extended */
727         {
728             put_dword( &menu16, get_dword( &menu32 ) );  /* fType */
729             put_dword( &menu16, get_dword( &menu32 ) );  /* fState */
730             put_word( &menu16, get_dword( &menu32 ) );   /* ID */
731             flags = get_word( &menu32 );
732             put_byte(&menu16,flags);
733
734             WideCharToMultiByte( CP_ACP, 0, menu32, -1, menu16, 0x7fffffff, NULL, NULL );
735             menu16 = (LPSTR)menu16 + strlen( menu16 ) + 1;
736             menu32 = (LPCWSTR)menu32 + strlenW( menu32 ) + 1;
737
738             /* align on DWORD boundary (32-bit only) */
739             menu32 = (LPCVOID)(((UINT_PTR)menu32 + 3) & ~3);
740
741             /* If popup, transfer helpid */
742             if ( flags & 1)
743             {
744                 put_dword( &menu16, get_dword( &menu32 ) );
745                 level++;
746             }
747
748             if ( flags & MF_END )
749                 level--;
750         }
751 }
752
753
754 /**********************************************************************
755  *          GetMenu32Size   (KERNEL.617)
756  */
757 WORD WINAPI GetMenu32Size16( LPCVOID menu32 )
758 {
759     LPCVOID p = menu32;
760     WORD version, headersize, flags, level = 1;
761
762     version = get_word(&p);
763     headersize = get_word(&p);
764     p = (const BYTE *)p + headersize;
765
766     while ( level )
767         if ( version == 0 )  /* standard */
768         {
769             flags = get_word(&p);
770             if ( !(flags & MF_POPUP) )
771                 p = (const WORD *)p + 1;  /* ID */
772             else
773                 level++;
774
775             p = (LPCWSTR)p + strlenW( p ) + 1;
776
777             if ( flags & MF_END )
778                 level--;
779         }
780         else  /* extended */
781         {
782             p = (const DWORD *)p + 1; /* fType */
783             p = (const DWORD *)p + 1; /* fState */
784             p = (const DWORD *)p + 1; /* ID */
785             flags = get_word(&p);
786
787             p = (LPCWSTR)p + strlenW( p ) + 1;
788
789             /* align on DWORD boundary (32-bit only) */
790             p = (LPCVOID)(((UINT_PTR)p + 3) & ~3);
791
792             /* If popup, skip helpid */
793             if ( flags & 1)
794             {
795                 p = (const DWORD *)p + 1;
796                 level++;
797             }
798
799             if ( flags & MF_END )
800                 level--;
801         }
802
803     return (WORD)((LPCSTR)p - (LPCSTR)menu32);
804 }
805
806
807 /**********************************************************************
808  *          ConvertAccelerator32To16
809  */
810 static void ConvertAccelerator32To16( LPCVOID acc32, DWORD size, LPVOID acc16 )
811 {
812     BYTE type;
813
814     do
815     {
816         /* Copy type */
817         type = get_byte(&acc32);
818         put_byte(&acc16, type);
819         /* Skip padding */
820         get_byte(&acc32);
821         /* Copy event and IDval */
822         put_word(&acc16, get_word(&acc32));
823         put_word(&acc16, get_word(&acc32));
824         /* Skip padding */
825         get_word(&acc32);
826
827     } while ( !( type & 0x80 ) );
828 }
829
830
831 /**********************************************************************
832  *          NE_LoadPEResource
833  */
834 static HGLOBAL16 NE_LoadPEResource( NE_MODULE *pModule, WORD type, LPCVOID bits, DWORD size )
835 {
836     HGLOBAL16 handle;
837
838     TRACE("module=%04x type=%04x\n", pModule->self, type );
839
840     handle = GlobalAlloc16( 0, size );
841
842     switch (type)
843     {
844     case RT_MENU:
845         ConvertMenu32To16( bits, size, GlobalLock16( handle ) );
846         break;
847     case RT_DIALOG:
848         ConvertDialog32To16( bits, size, GlobalLock16( handle ) );
849         break;
850     case RT_ACCELERATOR:
851         ConvertAccelerator32To16( bits, size, GlobalLock16( handle ) );
852         break;
853     case RT_STRING:
854         FIXME("not yet implemented!\n" );
855         /* fall through */
856     default:
857         memcpy( GlobalLock16( handle ), bits, size );
858         break;
859     }
860     return handle;
861 }
862
863
864 /**********************************************************************
865  *          AllocResource    (KERNEL.66)
866  */
867 HGLOBAL16 WINAPI AllocResource16( HMODULE16 hModule, HRSRC16 hRsrc, DWORD size)
868 {
869     NE_NAMEINFO *pNameInfo=NULL;
870     WORD sizeShift;
871     HGLOBAL16 ret;
872
873     NE_MODULE *pModule = NE_GetPtr( hModule );
874     if (!pModule || !pModule->ne_rsrctab || !hRsrc) return 0;
875
876     TRACE("module=%04x res=%04x size=%d\n", hModule, hRsrc, size );
877
878     sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab);
879     pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
880     if (size < (DWORD)pNameInfo->length << sizeShift)
881         size = (DWORD)pNameInfo->length << sizeShift;
882     ret = GlobalAlloc16( GMEM_FIXED, size );
883     if (ret) FarSetOwner16( ret, hModule );
884     return ret;
885 }
886
887
888 /**********************************************************************
889  *      DirectResAlloc    (KERNEL.168)
890  *
891  * Check Schulman, p. 232 for details
892  */
893 HGLOBAL16 WINAPI DirectResAlloc16( HINSTANCE16 hInstance, WORD wType,
894                                  UINT16 wSize )
895 {
896     HGLOBAL16 ret;
897     TRACE("(%04x,%04x,%04x)\n", hInstance, wType, wSize );
898     if (!(hInstance = GetExePtr( hInstance ))) return 0;
899     if(wType != 0x10)   /* 0x10 is the only observed value, passed from
900                            CreateCursorIndirect. */
901         TRACE("(wType=%x)\n", wType);
902     ret = GlobalAlloc16( GMEM_MOVEABLE, wSize );
903     if (ret) FarSetOwner16( ret, hInstance );
904     return ret;
905 }
906
907
908 /**********************************************************************
909  *          AccessResource (KERNEL.64)
910  */
911 INT16 WINAPI AccessResource16( HINSTANCE16 hModule, HRSRC16 hRsrc )
912 {
913     HFILE16 fd;
914     NE_MODULE *pModule = NE_GetPtr( hModule );
915
916     if (!pModule || !pModule->ne_rsrctab || !hRsrc) return -1;
917
918     TRACE("module=%04x res=%04x\n", pModule->self, hRsrc );
919
920     if ((fd = _lopen16( NE_MODULE_NAME(pModule), OF_READ )) != HFILE_ERROR16)
921     {
922         WORD sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab);
923         NE_NAMEINFO *pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
924         _llseek16( fd, (int)pNameInfo->offset << sizeShift, SEEK_SET );
925     }
926     return fd;
927 }
928
929
930 /**********************************************************************
931  *          FindResource     (KERNEL.60)
932  */
933 HRSRC16 WINAPI FindResource16( HMODULE16 hModule, LPCSTR name, LPCSTR type )
934 {
935     NE_TYPEINFO *pTypeInfo;
936     NE_NAMEINFO *pNameInfo;
937     LPBYTE pResTab;
938     NE_MODULE *pModule = get_module( hModule );
939
940     if (!pModule) return 0;
941
942     if (pModule->module32)
943     {
944         /* 32-bit PE module */
945         HRSRC hRsrc32 = FindResourceA( pModule->module32, name, type );
946         return MapHRsrc32To16( pModule, hRsrc32, HIWORD(type) ? 0 : LOWORD(type) );
947     }
948
949     TRACE("module=%04x name=%s type=%s\n", pModule->self, debugstr_a(name), debugstr_a(type) );
950
951     if (!pModule->ne_rsrctab) return 0;
952
953     type = get_res_name( type );
954     name = get_res_name( name );
955
956     if (HIWORD(type) || HIWORD(name))
957     {
958         DWORD id = NE_FindNameTableId( pModule, type, name );
959         if (id)  /* found */
960         {
961             type = (LPCSTR)(ULONG_PTR)LOWORD(id);
962             name = (LPCSTR)(ULONG_PTR)HIWORD(id);
963         }
964     }
965     pResTab = (LPBYTE)pModule + pModule->ne_rsrctab;
966     pTypeInfo = (NE_TYPEINFO *)( pResTab + 2 );
967
968     for (;;)
969     {
970         if (!(pTypeInfo = NE_FindTypeSection( pResTab, pTypeInfo, type ))) break;
971         if ((pNameInfo = NE_FindResourceFromType( pResTab, pTypeInfo, name )))
972         {
973             TRACE("    Found id %p\n", name );
974             return (HRSRC16)( (char *)pNameInfo - (char *)pModule );
975         }
976         pTypeInfo = next_typeinfo(pTypeInfo);
977     }
978     return 0;
979 }
980
981
982 /**********************************************************************
983  *          LoadResource     (KERNEL.61)
984  */
985 HGLOBAL16 WINAPI LoadResource16( HMODULE16 hModule, HRSRC16 hRsrc )
986 {
987     NE_TYPEINFO *pTypeInfo;
988     NE_NAMEINFO *pNameInfo = NULL;
989     NE_MODULE *pModule = get_module( hModule );
990     int d;
991
992     if (!hRsrc || !pModule) return 0;
993
994     if (pModule->module32)
995     {
996         /* load 32-bit resource and convert it */
997         HRSRC hRsrc32 = MapHRsrc16To32( pModule, hRsrc );
998         WORD type     = MapHRsrc16ToType( pModule, hRsrc );
999         HGLOBAL hMem  = LoadResource( pModule->module32, hRsrc32 );
1000         DWORD size    = SizeofResource( pModule->module32, hRsrc32 );
1001         if (!hMem) return 0;
1002         return NE_LoadPEResource( pModule, type, LockResource( hMem ), size );
1003     }
1004
1005     /* first, verify hRsrc (just an offset from pModule to the needed pNameInfo) */
1006
1007     d = pModule->ne_rsrctab + 2;
1008     pTypeInfo = (NE_TYPEINFO *)((char *)pModule + d);
1009     while( hRsrc > d )
1010     {
1011         if (pTypeInfo->type_id == 0) break; /* terminal entry */
1012         d += sizeof(NE_TYPEINFO) + pTypeInfo->count * sizeof(NE_NAMEINFO);
1013         if (hRsrc < d)
1014         {
1015             if( ((d - hRsrc)%sizeof(NE_NAMEINFO)) == 0 )
1016             {
1017                 pNameInfo = (NE_NAMEINFO *)((char *)pModule + hRsrc);
1018                 break;
1019             }
1020             else break; /* NE_NAMEINFO boundary mismatch */
1021         }
1022         pTypeInfo = (NE_TYPEINFO *)((char *)pModule + d);
1023     }
1024
1025     if (pNameInfo)
1026     {
1027         if (pNameInfo->handle && !(GlobalFlags16(pNameInfo->handle) & GMEM_DISCARDED))
1028         {
1029             pNameInfo->usage++;
1030             TRACE("  Already loaded, new count=%d\n", pNameInfo->usage );
1031         }
1032         else
1033         {
1034             FARPROC16 resloader;
1035             memcpy_unaligned( &resloader, &pTypeInfo->resloader, sizeof(FARPROC16) );
1036             if (resloader && resloader != get_default_res_handler())
1037             {
1038                 WORD args[3];
1039                 DWORD ret;
1040
1041                 args[2] = pNameInfo->handle;
1042                 args[1] = pModule->self;
1043                 args[0] = hRsrc;
1044                 WOWCallback16Ex( (DWORD)resloader, WCB16_PASCAL, sizeof(args), args, &ret );
1045                 pNameInfo->handle = LOWORD(ret);
1046             }
1047             else
1048                 pNameInfo->handle = NE_DefResourceHandler( pNameInfo->handle, pModule->self, hRsrc );
1049
1050             if (pNameInfo->handle)
1051             {
1052                 pNameInfo->usage++;
1053                 pNameInfo->flags |= NE_SEGFLAGS_LOADED;
1054             }
1055         }
1056         return pNameInfo->handle;
1057     }
1058     return 0;
1059 }
1060
1061
1062 /**********************************************************************
1063  *          LockResource   (KERNEL.62)
1064  */
1065 SEGPTR WINAPI WIN16_LockResource16( HGLOBAL16 handle )
1066 {
1067     TRACE("(%04x)\n", handle );
1068     /* May need to reload the resource if discarded */
1069     return WOWGlobalLock16( handle );
1070 }
1071
1072
1073 /**********************************************************************
1074  *          LockResource16 (KERNEL32.@)
1075  */
1076 LPVOID WINAPI LockResource16( HGLOBAL16 handle )
1077 {
1078     return MapSL( WIN16_LockResource16(handle) );
1079 }
1080
1081
1082 /**********************************************************************
1083  *          SizeofResource   (KERNEL.65)
1084  */
1085 DWORD WINAPI SizeofResource16( HMODULE16 hModule, HRSRC16 hRsrc )
1086 {
1087     NE_MODULE *pModule = NE_GetPtr( hModule );
1088
1089     TRACE("(%x, %x)\n", hModule, hRsrc );
1090
1091     if (!hRsrc) return 0;
1092     if (!(pModule = get_module( hModule ))) return 0;
1093     if (pModule->ne_rsrctab)
1094     {
1095         WORD sizeShift = *(WORD *)((char *)pModule + pModule->ne_rsrctab);
1096         NE_NAMEINFO *pNameInfo = (NE_NAMEINFO*)((char*)pModule + hRsrc);
1097         return (DWORD)pNameInfo->length << sizeShift;
1098     }
1099     if (pModule->module32)
1100     {
1101         /* 32-bit PE module */
1102         return SizeofResource( pModule->module32, MapHRsrc16To32( pModule, hRsrc ) );
1103     }
1104     return 0;
1105 }
1106
1107
1108 typedef WORD (WINAPI *pDestroyIcon32Proc)( HGLOBAL16 handle, UINT16 flags );
1109
1110 /**********************************************************************
1111  *          FreeResource     (KERNEL.63)
1112  */
1113 BOOL16 WINAPI FreeResource16( HGLOBAL16 handle )
1114 {
1115     pDestroyIcon32Proc proc;
1116     HMODULE user;
1117     NE_MODULE *pModule = NE_GetPtr( FarGetOwner16( handle ) );
1118
1119     TRACE("(%04x)\n", handle );
1120
1121     /* Try NE resource first */
1122
1123     if (pModule && pModule->ne_rsrctab)
1124     {
1125         NE_TYPEINFO *pTypeInfo = (NE_TYPEINFO *)((char *)pModule + pModule->ne_rsrctab + 2);
1126         while (pTypeInfo->type_id)
1127         {
1128             WORD count;
1129             NE_NAMEINFO *pNameInfo = (NE_NAMEINFO *)(pTypeInfo + 1);
1130             for (count = pTypeInfo->count; count > 0; count--)
1131             {
1132                 if (pNameInfo->handle == handle)
1133                 {
1134                     if (pNameInfo->usage > 0) pNameInfo->usage--;
1135                     if (pNameInfo->usage == 0)
1136                     {
1137                         GlobalFree16( pNameInfo->handle );
1138                         pNameInfo->handle = 0;
1139                         pNameInfo->flags &= ~NE_SEGFLAGS_LOADED;
1140                     }
1141                     return 0;
1142                 }
1143                 pNameInfo++;
1144             }
1145             pTypeInfo = (NE_TYPEINFO *)pNameInfo;
1146         }
1147     }
1148
1149     /* If this failed, call USER.DestroyIcon32; this will check
1150        whether it is a shared cursor/icon; if not it will call
1151        GlobalFree16() */
1152     user = GetModuleHandleA( "user32.dll" );
1153     if (user && (proc = (pDestroyIcon32Proc)GetProcAddress( user, "DestroyIcon32" )))
1154         return proc( handle, 1 /*CID_RESOURCE*/ );
1155     else
1156         return GlobalFree16( handle );
1157 }