4 * Copyright 1993 Yngvi Sigurjonsson (yngvi@hafro.is)
5 * Copyright 1996 Marcus Meissner
19 # define iswalnum(c) isalnum(c)
20 # define iswalpha(c) isalpha(c)
21 # define iswupper(c) isupper(c)
22 # define iswlower(c) islower(c)
23 #endif /* HAVE_WCTYPE_H */
29 #include "wine/winbase16.h"
30 #include "wine/winuser16.h"
31 #include "wine/unicode.h"
36 #include "stackframe.h"
38 #include "debugtools.h"
40 DEFAULT_DEBUG_CHANNEL(resource
);
42 extern const WORD OLE2NLS_CT_CType3_LUT
[]; /* FIXME: does not belong here */
44 /* Funny to divide them between user and kernel. */
46 /***********************************************************************
47 * IsCharAlpha (USER.433)
49 BOOL16 WINAPI
IsCharAlpha16(CHAR ch
)
51 return isalpha(ch
); /* This is probably not right for NLS */
54 /***********************************************************************
55 * IsCharAlphaNumeric (USER.434)
57 BOOL16 WINAPI
IsCharAlphaNumeric16(CHAR ch
)
62 /***********************************************************************
63 * IsCharUpper (USER.435)
65 BOOL16 WINAPI
IsCharUpper16(CHAR ch
)
70 /***********************************************************************
71 * IsCharLower (USER.436)
73 BOOL16 WINAPI
IsCharLower16(CHAR ch
)
78 /***********************************************************************
79 * AnsiUpper16 (USER.431)
81 SEGPTR WINAPI
AnsiUpper16( SEGPTR strOrChar
)
83 /* I am not sure if the locale stuff works with toupper, but then again
84 I am not sure if the Linux libc locale stuffs works at all */
86 /* uppercase only one char if strOrChar < 0x10000 */
87 if (HIWORD(strOrChar
))
90 for (s
= PTR_SEG_TO_LIN(strOrChar
); *s
; s
++) *s
= toupper(*s
);
93 else return toupper((char)strOrChar
);
97 /***********************************************************************
98 * AnsiUpperBuff16 (USER.437)
100 UINT16 WINAPI
AnsiUpperBuff16( LPSTR str
, UINT16 len
)
102 UINT count
= len
? len
: 65536;
103 for (; count
; count
--, str
++) *str
= toupper(*str
);
107 /***********************************************************************
108 * AnsiLower16 (USER.432)
110 SEGPTR WINAPI
AnsiLower16( SEGPTR strOrChar
)
112 /* I am not sure if the locale stuff works with toupper, but then again
113 I am not sure if the Linux libc locale stuffs works at all */
115 /* lowercase only one char if strOrChar < 0x10000 */
116 if (HIWORD(strOrChar
))
119 for (s
= PTR_SEG_TO_LIN( strOrChar
); *s
; s
++) *s
= tolower( *s
);
122 else return tolower((char)strOrChar
);
126 /***********************************************************************
127 * AnsiLowerBuff16 (USER.438)
129 UINT16 WINAPI
AnsiLowerBuff16( LPSTR str
, UINT16 len
)
131 UINT count
= len
? len
: 65536;
132 for (; count
; count
--, str
++) *str
= tolower(*str
);
137 /***********************************************************************
138 * AnsiNext16 (USER.472)
140 SEGPTR WINAPI
AnsiNext16(SEGPTR current
)
142 return (*(char *)PTR_SEG_TO_LIN(current
)) ? current
+ 1 : current
;
146 /***********************************************************************
147 * AnsiPrev16 (USER.473)
149 SEGPTR WINAPI
AnsiPrev16( SEGPTR start
, SEGPTR current
)
151 return (current
== start
) ? start
: current
- 1;
155 /***********************************************************************
156 * CharNextA (USER32.29)
158 LPSTR WINAPI
CharNextA( LPCSTR ptr
)
160 if (!*ptr
) return (LPSTR
)ptr
;
161 if (IsDBCSLeadByte( *ptr
) && (*(ptr
+1) != 0) ) return (LPSTR
)(ptr
+ 2);
162 return (LPSTR
)(ptr
+ 1);
166 /***********************************************************************
167 * CharNextExA (USER32.30)
169 LPSTR WINAPI
CharNextExA( WORD codepage
, LPCSTR ptr
, DWORD flags
)
171 if (!*ptr
) return (LPSTR
)ptr
;
172 if (IsDBCSLeadByteEx( codepage
, *ptr
) && (*(ptr
+1) != 0) ) return (LPSTR
)(ptr
+ 2);
173 return (LPSTR
)(ptr
+ 1);
177 /***********************************************************************
178 * CharNextExW (USER32.31)
180 LPWSTR WINAPI
CharNextExW(WORD codepage
,LPCWSTR x
,DWORD flags
)
182 /* FIXME: add DBCS / codepage stuff */
183 if (*x
) return (LPWSTR
)(x
+1);
184 else return (LPWSTR
)x
;
187 /***********************************************************************
188 * CharNextW (USER32.32)
190 LPWSTR WINAPI
CharNextW(LPCWSTR x
)
192 if (*x
) return (LPWSTR
)(x
+1);
193 else return (LPWSTR
)x
;
196 /***********************************************************************
197 * CharPrevA (USER32.33)
199 LPSTR WINAPI
CharPrevA( LPCSTR start
, LPCSTR ptr
)
201 while (*start
&& (start
< ptr
))
203 LPCSTR next
= CharNextA( start
);
204 if (next
>= ptr
) break;
211 /***********************************************************************
212 * CharPrevExA (USER32.34)
214 LPSTR WINAPI
CharPrevExA( WORD codepage
, LPCSTR start
, LPCSTR ptr
, DWORD flags
)
216 while (*start
&& (start
< ptr
))
218 LPCSTR next
= CharNextExA( codepage
, start
, flags
);
219 if (next
> ptr
) break;
226 /***********************************************************************
227 * CharPrevExW (USER32.35)
229 LPWSTR WINAPI
CharPrevExW(WORD codepage
,LPCWSTR start
,LPCWSTR x
,DWORD flags
)
231 /* FIXME: add DBCS / codepage stuff */
232 if (x
>start
) return (LPWSTR
)(x
-1);
233 else return (LPWSTR
)x
;
236 /***********************************************************************
237 * CharPrevW (USER32.36)
239 LPWSTR WINAPI
CharPrevW(LPCWSTR start
,LPCWSTR x
)
241 if (x
>start
) return (LPWSTR
)(x
-1);
242 else return (LPWSTR
)x
;
245 /***********************************************************************
246 * CharLowerA (USER32.25)
247 * FIXME: handle current locale
249 LPSTR WINAPI
CharLowerA(LPSTR x
)
263 else return (LPSTR
)tolower((char)(int)x
);
266 /***********************************************************************
267 * CharLowerBuffA (USER32.26)
268 * FIXME: handle current locale
270 DWORD WINAPI
CharLowerBuffA(LPSTR x
,DWORD buflen
)
274 if (!x
) return 0; /* YES */
275 while (*x
&& (buflen
--))
284 /***********************************************************************
285 * CharLowerBuffW (USER32.27)
287 DWORD WINAPI
CharLowerBuffW(LPWSTR x
,DWORD buflen
)
291 if (!x
) return 0; /* YES */
292 while (*x
&& (buflen
--))
301 /***********************************************************************
302 * CharLowerW (USER32.28)
303 * FIXME: handle current locale
305 LPWSTR WINAPI
CharLowerW(LPWSTR x
)
317 else return (LPWSTR
)((UINT
)tolowerW(LOWORD(x
)));
320 /***********************************************************************
321 * CharUpperA (USER32.41)
322 * FIXME: handle current locale
324 LPSTR WINAPI
CharUpperA(LPSTR x
)
336 return (LPSTR
)toupper((char)(int)x
);
339 /***********************************************************************
340 * CharUpperBuffA (USER32.42)
341 * FIXME: handle current locale
343 DWORD WINAPI
CharUpperBuffA(LPSTR x
,DWORD buflen
)
347 if (!x
) return 0; /* YES */
348 while (*x
&& (buflen
--))
357 /***********************************************************************
358 * CharUpperBuffW (USER32.43)
359 * FIXME: handle current locale
361 DWORD WINAPI
CharUpperBuffW(LPWSTR x
,DWORD buflen
)
365 if (!x
) return 0; /* YES */
366 while (*x
&& (buflen
--))
375 /***********************************************************************
376 * CharUpperW (USER32.44)
377 * FIXME: handle current locale
379 LPWSTR WINAPI
CharUpperW(LPWSTR x
)
391 else return (LPWSTR
)((UINT
)toupperW(LOWORD(x
)));
394 /***********************************************************************
395 * IsCharAlphaA (USER32.331)
396 * FIXME: handle current locale
398 BOOL WINAPI
IsCharAlphaA(CHAR x
)
400 return (OLE2NLS_CT_CType3_LUT
[(unsigned char)x
] & C3_ALPHA
);
403 /***********************************************************************
404 * IsCharAlphaNumericA (USER32.332)
405 * FIXME: handle current locale
407 BOOL WINAPI
IsCharAlphaNumericA(CHAR x
)
409 return IsCharAlphaA(x
) || isdigit(x
) ;
412 /***********************************************************************
413 * IsCharAlphaNumericW (USER32.333)
414 * FIXME: handle current locale
416 BOOL WINAPI
IsCharAlphaNumericW(WCHAR x
)
421 /***********************************************************************
422 * IsCharAlphaW (USER32.334)
423 * FIXME: handle current locale
425 BOOL WINAPI
IsCharAlphaW(WCHAR x
)
430 /***********************************************************************
431 * IsCharLowerA (USER32.335)
432 * FIXME: handle current locale
434 BOOL WINAPI
IsCharLowerA(CHAR x
)
439 /***********************************************************************
440 * IsCharLowerW (USER32.336)
441 * FIXME: handle current locale
443 BOOL WINAPI
IsCharLowerW(WCHAR x
)
448 /***********************************************************************
449 * IsCharUpperA (USER32.337)
450 * FIXME: handle current locale
452 BOOL WINAPI
IsCharUpperA(CHAR x
)
457 /***********************************************************************
458 * IsCharUpperW (USER32.338)
459 * FIXME: handle current locale
461 BOOL WINAPI
IsCharUpperW(WCHAR x
)
466 /***********************************************************************
467 * FormatMessage16 (USER.606)
469 DWORD WINAPI
FormatMessage16(
471 SEGPTR lpSource
, /*not always a valid pointer*/
474 LPSTR lpBuffer
, /* *((HLOCAL16*)) for FORMAT_MESSAGE_ALLOCATE_BUFFER*/
476 LPDWORD args
/* va_list *args */
479 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
483 DWORD width
= dwFlags
& FORMAT_MESSAGE_MAX_WIDTH_MASK
;
485 LPSTR allocstring
= NULL
;
487 TRACE("(0x%lx,%lx,%d,0x%x,%p,%d,%p)\n",
488 dwFlags
,lpSource
,dwMessageId
,dwLanguageId
,lpBuffer
,nSize
,args
);
490 FIXME("line wrapping not supported.\n");
492 if (dwFlags
& FORMAT_MESSAGE_FROM_STRING
)
493 from
= HEAP_strdupA( GetProcessHeap(), 0, PTR_SEG_TO_LIN(lpSource
));
494 if (dwFlags
& FORMAT_MESSAGE_FROM_SYSTEM
) {
495 from
= HeapAlloc( GetProcessHeap(),0,200 );
496 sprintf(from
,"Systemmessage, messageid = 0x%08x\n",dwMessageId
);
498 if (dwFlags
& FORMAT_MESSAGE_FROM_HMODULE
) {
500 HINSTANCE16 hinst16
= ((HMODULE
)lpSource
& 0xffff);
502 dwMessageId
&= 0xFFFF;
503 bufsize
=LoadString16(hinst16
,dwMessageId
,NULL
,0);
505 from
= HeapAlloc( GetProcessHeap(), 0, bufsize
+1);
506 LoadString16(hinst16
,dwMessageId
,from
,bufsize
+1);
509 target
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 100);
513 #define ADD_TO_T(c) \
515 if (t-target == talloced) {\
516 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
517 t = target+talloced;\
526 char *fmtstr
,*sprintfbuf
,*x
,*lastf
;
537 case '1':case '2':case '3':case '4':case '5':
538 case '6':case '7':case '8':case '9':
541 case '0':case '1':case '2':case '3':
542 case '4':case '5':case '6':case '7':
545 insertnr
=insertnr
*10+*f
-'0';
554 if (NULL
!=(x
=strchr(f
,'!'))) {
556 fmtstr
=HeapAlloc(GetProcessHeap(),0,strlen(f
)+2);
557 sprintf(fmtstr
,"%%%s",f
);
560 fmtstr
=HeapAlloc(GetProcessHeap(),0,strlen(f
));
561 sprintf(fmtstr
,"%%%s",f
);
562 f
+=strlen(f
); /*at \0*/
568 fmtstr
=HEAP_strdupA(GetProcessHeap(),0,"%s");
570 argliststart
=args
+insertnr
-1;
571 if (fmtstr
[strlen(fmtstr
)-1]=='s')
572 sprintfbuf
=HeapAlloc(GetProcessHeap(),0,
573 strlen(PTR_SEG_TO_LIN(argliststart
[0]))+1);
575 sprintfbuf
=HeapAlloc(GetProcessHeap(),0,100);
577 /* CMF - This makes a BIG assumption about va_list */
578 wvsprintf16(sprintfbuf
, fmtstr
, (va_list) argliststart
);
583 HeapFree(GetProcessHeap(),0,sprintfbuf
);
585 /* NULL args - copy formatstr
588 while ((lastf
<f
)&&(*lastf
)) {
592 HeapFree(GetProcessHeap(),0,fmtstr
);
594 case '0': /* Just stop processing format string */
598 case 'n': /* 16 bit version just outputs 'n' */
603 } else { /* '\n' or '\r' gets mapped to "\r\n" */
604 if(*f
== '\n' || *f
== '\r') {
607 if(*f
++ == '\r' && *f
== '\n')
616 talloced
= strlen(target
)+1;
617 if (nSize
&& talloced
<nSize
) {
618 target
= (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,target
,nSize
);
620 TRACE("-- %s\n",debugstr_a(target
));
621 if (dwFlags
& FORMAT_MESSAGE_ALLOCATE_BUFFER
) {
622 /* nSize is the MINIMUM size */
623 *((HLOCAL16
*)lpBuffer
)= LocalAlloc16(LPTR
,talloced
);
624 allocstring
=PTR_SEG_OFF_TO_LIN(CURRENT_DS
,*((HLOCAL16
*)lpBuffer
));
625 memcpy( allocstring
,target
,talloced
);
627 lstrcpynA(lpBuffer
,target
,nSize
);
628 HeapFree(GetProcessHeap(),0,target
);
629 if (from
) HeapFree(GetProcessHeap(),0,from
);
630 return (dwFlags
& FORMAT_MESSAGE_ALLOCATE_BUFFER
) ?
635 #endif /* __i386__ */
639 /***********************************************************************
640 * FormatMessageA (KERNEL32.138)
641 * FIXME: missing wrap,FROM_SYSTEM message-loading,
643 DWORD WINAPI
FormatMessageA(
650 LPDWORD args
/* va_list *args */
653 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
657 DWORD width
= dwFlags
& FORMAT_MESSAGE_MAX_WIDTH_MASK
;
660 TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
661 dwFlags
,lpSource
,dwMessageId
,dwLanguageId
,lpBuffer
,nSize
,args
);
663 FIXME("line wrapping not supported.\n");
665 if (dwFlags
& FORMAT_MESSAGE_FROM_STRING
)
666 from
= HEAP_strdupA( GetProcessHeap(), 0, (LPSTR
)lpSource
);
667 if (dwFlags
& FORMAT_MESSAGE_FROM_SYSTEM
) {
668 from
= HeapAlloc( GetProcessHeap(),0,200 );
669 sprintf(from
,"Systemmessage, messageid = 0x%08lx\n",dwMessageId
);
671 if (dwFlags
& FORMAT_MESSAGE_FROM_HMODULE
) {
674 dwMessageId
&= 0xFFFF;
675 bufsize
=LoadMessageA((HMODULE
)lpSource
,dwMessageId
,dwLanguageId
,NULL
,100);
677 from
= HeapAlloc( GetProcessHeap(), 0, bufsize
+ 1 );
678 LoadMessageA((HMODULE
)lpSource
,dwMessageId
,dwLanguageId
,from
,bufsize
+1);
681 target
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 100);
685 #define ADD_TO_T(c) \
687 if (t-target == talloced) {\
688 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
689 t = target+talloced;\
698 char *fmtstr
,*sprintfbuf
,*x
,*lastf
;
709 case '1':case '2':case '3':case '4':case '5':
710 case '6':case '7':case '8':case '9':
713 case '0':case '1':case '2':case '3':
714 case '4':case '5':case '6':case '7':
717 insertnr
=insertnr
*10+*f
-'0';
726 if (NULL
!=(x
=strchr(f
,'!'))) {
728 fmtstr
=HeapAlloc(GetProcessHeap(),0,strlen(f
)+2);
729 sprintf(fmtstr
,"%%%s",f
);
732 fmtstr
=HeapAlloc(GetProcessHeap(),0,strlen(f
));
733 sprintf(fmtstr
,"%%%s",f
);
734 f
+=strlen(f
); /*at \0*/
740 fmtstr
=HEAP_strdupA(GetProcessHeap(),0,"%s");
742 if (dwFlags
& FORMAT_MESSAGE_ARGUMENT_ARRAY
)
743 argliststart
=args
+insertnr
-1;
745 argliststart
=(*(DWORD
**)args
)+insertnr
-1;
747 if (fmtstr
[strlen(fmtstr
)-1]=='s' && argliststart
[0])
748 sprintfbuf
=HeapAlloc(GetProcessHeap(),0,strlen((LPSTR
)argliststart
[0])+1);
750 sprintfbuf
=HeapAlloc(GetProcessHeap(),0,100);
752 /* CMF - This makes a BIG assumption about va_list */
753 wvsprintfA(sprintfbuf
, fmtstr
, (va_list) argliststart
);
758 HeapFree(GetProcessHeap(),0,sprintfbuf
);
760 /* NULL args - copy formatstr
763 while ((lastf
<f
)&&(*lastf
)) {
767 HeapFree(GetProcessHeap(),0,fmtstr
);
782 } else { /* '\n' or '\r' gets mapped to "\r\n" */
783 if(*f
== '\n' || *f
== '\r') {
786 if(*f
++ == '\r' && *f
== '\n')
795 talloced
= strlen(target
)+1;
796 if (nSize
&& talloced
<nSize
) {
797 target
= (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,target
,nSize
);
799 TRACE("-- %s\n",debugstr_a(target
));
800 if (dwFlags
& FORMAT_MESSAGE_ALLOCATE_BUFFER
) {
801 /* nSize is the MINIMUM size */
802 *((LPVOID
*)lpBuffer
) = (LPVOID
)LocalAlloc(GMEM_ZEROINIT
,talloced
);
803 memcpy(*(LPSTR
*)lpBuffer
,target
,talloced
);
805 lstrcpynA(lpBuffer
,target
,nSize
);
807 HeapFree(GetProcessHeap(),0,target
);
808 if (from
) HeapFree(GetProcessHeap(),0,from
);
809 return (dwFlags
& FORMAT_MESSAGE_ALLOCATE_BUFFER
) ?
810 strlen(*(LPSTR
*)lpBuffer
):
814 #endif /* __i386__ */
819 /***********************************************************************
820 * FormatMessageW (KERNEL32.138)
822 DWORD WINAPI
FormatMessageW(
829 LPDWORD args
/* va_list *args */
832 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
836 DWORD width
= dwFlags
& FORMAT_MESSAGE_MAX_WIDTH_MASK
;
839 TRACE("(0x%lx,%p,%ld,0x%lx,%p,%ld,%p)\n",
840 dwFlags
,lpSource
,dwMessageId
,dwLanguageId
,lpBuffer
,nSize
,args
);
842 FIXME("line wrapping not supported.\n");
844 if (dwFlags
& FORMAT_MESSAGE_FROM_STRING
)
845 from
= HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR
)lpSource
);
846 if (dwFlags
& FORMAT_MESSAGE_FROM_SYSTEM
) {
847 /* gather information from system message tables ... */
848 from
= HeapAlloc( GetProcessHeap(),0,200 );
849 sprintf(from
,"Systemmessage, messageid = 0x%08lx\n",dwMessageId
);
851 if (dwFlags
& FORMAT_MESSAGE_FROM_HMODULE
) {
854 dwMessageId
&= 0xFFFF;
855 bufsize
=LoadMessageA((HMODULE
)lpSource
,dwMessageId
,dwLanguageId
,NULL
,100);
858 from
= HeapAlloc( GetProcessHeap(), 0, bufsize
+ 1 );
859 LoadMessageA((HMODULE
)lpSource
,dwMessageId
,dwLanguageId
,from
,bufsize
+1);
862 target
= HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY
, 100 );
866 #define ADD_TO_T(c) \
868 if (t-target == talloced) {\
869 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
870 t = target+talloced;\
879 char *fmtstr
,*sprintfbuf
,*x
;
889 case '1':case '2':case '3':case '4':case '5':
890 case '6':case '7':case '8':case '9':
893 case '0':case '1':case '2':case '3':
894 case '4':case '5':case '6':case '7':
897 insertnr
=insertnr
*10+*f
-'0';
906 if (NULL
!=(x
=strchr(f
,'!')))
909 fmtstr
=HeapAlloc( GetProcessHeap(), 0, strlen(f
)+2);
910 sprintf(fmtstr
,"%%%s",f
);
913 fmtstr
=HeapAlloc(GetProcessHeap(),0,strlen(f
));
914 sprintf(fmtstr
,"%%%s",f
);
915 f
+=strlen(f
); /*at \0*/
921 fmtstr
=HEAP_strdupA( GetProcessHeap(),0,"%s");
922 if (dwFlags
& FORMAT_MESSAGE_ARGUMENT_ARRAY
)
923 argliststart
=args
+insertnr
-1;
925 argliststart
=(*(DWORD
**)args
)+insertnr
-1;
927 if (fmtstr
[strlen(fmtstr
)-1]=='s' && argliststart
[0]) {
930 xarr
[0]=(DWORD
)HEAP_strdupWtoA(GetProcessHeap(),0,(LPWSTR
)(*(argliststart
+0)));
931 /* possible invalid pointers */
932 xarr
[1]=*(argliststart
+1);
933 xarr
[2]=*(argliststart
+2);
934 sprintfbuf
=HeapAlloc(GetProcessHeap(),0,lstrlenW((LPWSTR
)argliststart
[0])*2+1);
936 /* CMF - This makes a BIG assumption about va_list */
937 vsprintf(sprintfbuf
, fmtstr
, (va_list) xarr
);
939 sprintfbuf
=HeapAlloc(GetProcessHeap(),0,100);
941 /* CMF - This makes a BIG assumption about va_list */
942 wvsprintfA(sprintfbuf
, fmtstr
, (va_list) argliststart
);
948 HeapFree(GetProcessHeap(),0,sprintfbuf
);
949 HeapFree(GetProcessHeap(),0,fmtstr
);
964 } else { /* '\n' or '\r' gets mapped to "\r\n" */
965 if(*f
== '\n' || *f
== '\r') {
968 if(*f
++ == '\r' && *f
== '\n')
977 talloced
= strlen(target
)+1;
978 if (nSize
&& talloced
<nSize
)
979 target
= (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY
,target
,nSize
);
980 if (dwFlags
& FORMAT_MESSAGE_ALLOCATE_BUFFER
) {
981 /* nSize is the MINIMUM size */
982 *((LPVOID
*)lpBuffer
) = (LPVOID
)LocalAlloc(GMEM_ZEROINIT
,talloced
*2+2);
983 lstrcpynAtoW(*(LPWSTR
*)lpBuffer
,target
,talloced
);
985 lstrcpynAtoW(lpBuffer
,target
,nSize
);
986 HeapFree(GetProcessHeap(),0,target
);
987 if (from
) HeapFree(GetProcessHeap(),0,from
);
988 return (dwFlags
& FORMAT_MESSAGE_ALLOCATE_BUFFER
) ?
989 lstrlenW(*(LPWSTR
*)lpBuffer
):
993 #endif /* __i386__ */