2 * USER string functions
4 * Copyright 1993 Yngvi Sigurjonsson (yngvi@hafro.is)
5 * Copyright 1996 Alexandre Julliard
6 * Copyright 1996 Marcus Meissner
17 #include "wine/winbase16.h"
18 #include "wine/winuser16.h"
19 #include "wine/unicode.h"
23 #include "debugtools.h"
25 DEFAULT_DEBUG_CHANNEL(resource);
27 /***********************************************************************
28 * AnsiToOem16 (KEYBOARD.5)
30 INT16 WINAPI AnsiToOem16( LPCSTR s, LPSTR d )
37 /***********************************************************************
38 * OemToAnsi16 (KEYBOARD.6)
40 INT16 WINAPI OemToAnsi16( LPCSTR s, LPSTR d )
47 /***********************************************************************
48 * AnsiToOemBuff16 (KEYBOARD.134)
50 void WINAPI AnsiToOemBuff16( LPCSTR s, LPSTR d, UINT16 len )
52 if (len != 0) CharToOemBuffA( s, d, len );
56 /***********************************************************************
57 * OemToAnsiBuff16 (KEYBOARD.135)
59 void WINAPI OemToAnsiBuff16( LPCSTR s, LPSTR d, UINT16 len )
61 if (len != 0) OemToCharBuffA( s, d, len );
65 /***********************************************************************
66 * AnsiUpper16 (USER.431)
68 SEGPTR WINAPI AnsiUpper16( SEGPTR strOrChar )
70 /* uppercase only one char if strOrChar < 0x10000 */
71 if (HIWORD(strOrChar))
73 CharUpperA( PTR_SEG_TO_LIN(strOrChar) );
76 else return toupper((char)strOrChar);
80 /***********************************************************************
81 * AnsiLower16 (USER.432)
83 SEGPTR WINAPI AnsiLower16( SEGPTR strOrChar )
85 /* lowercase only one char if strOrChar < 0x10000 */
86 if (HIWORD(strOrChar))
88 CharLowerA( PTR_SEG_TO_LIN(strOrChar) );
91 else return tolower((char)strOrChar);
95 /***********************************************************************
96 * AnsiUpperBuff16 (USER.437)
98 UINT16 WINAPI AnsiUpperBuff16( LPSTR str, UINT16 len )
100 CharUpperBuffA( str, len ? len : 65536 );
105 /***********************************************************************
106 * AnsiLowerBuff16 (USER.438)
108 UINT16 WINAPI AnsiLowerBuff16( LPSTR str, UINT16 len )
110 CharLowerBuffA( str, len ? len : 65536 );
115 /***********************************************************************
116 * AnsiNext16 (USER.472)
118 SEGPTR WINAPI AnsiNext16(SEGPTR current)
120 char *ptr = (char *)PTR_SEG_TO_LIN(current);
121 return current + (CharNextA(ptr) - ptr);
125 /***********************************************************************
126 * AnsiPrev16 (USER.473)
128 SEGPTR WINAPI AnsiPrev16( LPCSTR start, SEGPTR current )
130 char *ptr = (char *)PTR_SEG_TO_LIN(current);
131 return current - (ptr - CharPrevA( start, ptr ));
135 /***********************************************************************
136 * CharNextA (USER32.@)
138 LPSTR WINAPI CharNextA( LPCSTR ptr )
140 if (!*ptr) return (LPSTR)ptr;
141 if (IsDBCSLeadByte( ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
142 return (LPSTR)(ptr + 1);
146 /***********************************************************************
147 * CharNextExA (USER32.@)
149 LPSTR WINAPI CharNextExA( WORD codepage, LPCSTR ptr, DWORD flags )
151 if (!*ptr) return (LPSTR)ptr;
152 if (IsDBCSLeadByteEx( codepage, ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
153 return (LPSTR)(ptr + 1);
157 /***********************************************************************
158 * CharNextExW (USER32.@)
160 LPWSTR WINAPI CharNextExW( WORD codepage, LPCWSTR ptr, DWORD flags )
162 /* doesn't make sense, there are no codepages for Unicode */
167 /***********************************************************************
168 * CharNextW (USER32.@)
170 LPWSTR WINAPI CharNextW(LPCWSTR x)
178 /***********************************************************************
179 * CharPrevA (USER32.@)
181 LPSTR WINAPI CharPrevA( LPCSTR start, LPCSTR ptr )
183 while (*start && (start < ptr))
185 LPCSTR next = CharNextA( start );
186 if (next >= ptr) break;
193 /***********************************************************************
194 * CharPrevExA (USER32.@)
196 LPSTR WINAPI CharPrevExA( WORD codepage, LPCSTR start, LPCSTR ptr, DWORD flags )
198 while (*start && (start < ptr))
200 LPCSTR next = CharNextExA( codepage, start, flags );
201 if (next > ptr) break;
208 /***********************************************************************
209 * CharPrevExW (USER32.@)
211 LPSTR WINAPI CharPrevExW( WORD codepage, LPCWSTR start, LPCWSTR ptr, DWORD flags )
213 /* doesn't make sense, there are no codepages for Unicode */
218 /***********************************************************************
219 * CharPrevW (USER32.@)
221 LPWSTR WINAPI CharPrevW(LPCWSTR start,LPCWSTR x)
223 if (x>start) return (LPWSTR)(x-1);
224 else return (LPWSTR)x;
228 /***********************************************************************
229 * CharToOemA (USER32.@)
231 BOOL WINAPI CharToOemA( LPCSTR s, LPSTR d )
233 if ( !s || !d ) return TRUE;
234 return CharToOemBuffA( s, d, strlen( s ) + 1 );
238 /***********************************************************************
239 * CharToOemBuffA (USER32.@)
241 BOOL WINAPI CharToOemBuffA( LPCSTR s, LPSTR d, DWORD len )
245 bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
248 MultiByteToWideChar( CP_ACP, 0, s, len, bufW, len );
249 WideCharToMultiByte( CP_OEMCP, 0, bufW, len, d, len, NULL, NULL );
250 HeapFree( GetProcessHeap(), 0, bufW );
256 /***********************************************************************
257 * CharToOemBuffW (USER32.@)
259 BOOL WINAPI CharToOemBuffW( LPCWSTR s, LPSTR d, DWORD len )
261 if ( !s || !d ) return TRUE;
262 WideCharToMultiByte( CP_OEMCP, 0, s, len, d, len, NULL, NULL );
267 /***********************************************************************
268 * CharToOemW (USER32.@)
270 BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
272 return CharToOemBuffW( s, d, strlenW( s ) + 1 );
276 /***********************************************************************
277 * OemToCharA (USER32.@)
279 BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
281 return OemToCharBuffA( s, d, strlen( s ) + 1 );
285 /***********************************************************************
286 * OemToCharBuffA (USER32.@)
288 BOOL WINAPI OemToCharBuffA( LPCSTR s, LPSTR d, DWORD len )
292 bufW = HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
295 MultiByteToWideChar( CP_OEMCP, 0, s, len, bufW, len );
296 WideCharToMultiByte( CP_ACP, 0, bufW, len, d, len, NULL, NULL );
297 HeapFree( GetProcessHeap(), 0, bufW );
303 /***********************************************************************
304 * OemToCharBuffW (USER32.@)
306 BOOL WINAPI OemToCharBuffW( LPCSTR s, LPWSTR d, DWORD len )
308 MultiByteToWideChar( CP_OEMCP, 0, s, len, d, len );
313 /***********************************************************************
314 * OemToCharW (USER32.@)
316 BOOL WINAPI OemToCharW( LPCSTR s, LPWSTR d )
318 return OemToCharBuffW( s, d, strlen( s ) + 1 );
322 /***********************************************************************
323 * IsCharLowerA (USER.436) (USER32.@)
324 * FIXME: handle current locale
326 BOOL WINAPI IsCharLowerA(CHAR x)
332 /***********************************************************************
333 * IsCharLowerW (USER32.@)
335 BOOL WINAPI IsCharLowerW(WCHAR x)
337 return get_char_typeW(x) & C1_LOWER;
341 /***********************************************************************
342 * IsCharUpperA (USER.435) (USER32.337)
343 * FIXME: handle current locale
345 BOOL WINAPI IsCharUpperA(CHAR x)
351 /***********************************************************************
352 * IsCharUpperW (USER32.@)
354 BOOL WINAPI IsCharUpperW(WCHAR x)
356 return get_char_typeW(x) & C1_UPPER;
360 /***********************************************************************
361 * IsCharAlphaNumericW (USER32.@)
363 BOOL WINAPI IsCharAlphaNumericW(WCHAR x)
365 return get_char_typeW(x) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
369 /***********************************************************************
370 * IsCharAlphaW (USER32.@)
372 BOOL WINAPI IsCharAlphaW(WCHAR x)
374 return get_char_typeW(x) & (C1_ALPHA|C1_LOWER|C1_UPPER);
378 /***********************************************************************
379 * FormatMessage16 (USER.606)
381 DWORD WINAPI FormatMessage16(
383 SEGPTR lpSource, /*not always a valid pointer*/
386 LPSTR lpBuffer, /* *((HLOCAL16*)) for FORMAT_MESSAGE_ALLOCATE_BUFFER*/
388 LPDWORD args /* va_list *args */
391 /* This implementation is completely dependant on the format of the va_list on x86 CPUs */
395 DWORD width = dwFlags & FORMAT_MESSAGE_MAX_WIDTH_MASK;
397 LPSTR allocstring = NULL;
399 TRACE("(0x%lx,%lx,%d,0x%x,%p,%d,%p)\n",
400 dwFlags,lpSource,dwMessageId,dwLanguageId,lpBuffer,nSize,args);
401 if ((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
402 && (dwFlags & FORMAT_MESSAGE_FROM_HMODULE)) return 0;
403 if ((dwFlags & FORMAT_MESSAGE_FROM_STRING)
404 &&((dwFlags & FORMAT_MESSAGE_FROM_SYSTEM)
405 || (dwFlags & FORMAT_MESSAGE_FROM_HMODULE))) return 0;
407 if (width && width != FORMAT_MESSAGE_MAX_WIDTH_MASK)
408 FIXME("line wrapping (%lu) not supported.\n", width);
410 if (dwFlags & FORMAT_MESSAGE_FROM_STRING)
411 from = HEAP_strdupA( GetProcessHeap(), 0, PTR_SEG_TO_LIN(lpSource));
412 if (dwFlags & FORMAT_MESSAGE_FROM_SYSTEM) {
413 from = HeapAlloc( GetProcessHeap(),0,200 );
414 sprintf(from,"Systemmessage, messageid = 0x%08x\n",dwMessageId);
416 if (dwFlags & FORMAT_MESSAGE_FROM_HMODULE) {
418 HINSTANCE16 hinst16 = ((HMODULE)lpSource & 0xffff);
420 dwMessageId &= 0xFFFF;
421 bufsize=LoadString16(hinst16,dwMessageId,NULL,0);
423 from = HeapAlloc( GetProcessHeap(), 0, bufsize +1);
424 LoadString16(hinst16,dwMessageId,from,bufsize+1);
427 target = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, 100);
431 #define ADD_TO_T(c) \
433 if (t-target == talloced) {\
434 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,talloced*2);\
435 t = target+talloced;\
444 char *fmtstr,*x,*lastf;
455 case '1':case '2':case '3':case '4':case '5':
456 case '6':case '7':case '8':case '9':
459 case '0':case '1':case '2':case '3':
460 case '4':case '5':case '6':case '7':
463 insertnr=insertnr*10+*f-'0';
472 if (NULL!=(x=strchr(f,'!'))) {
474 fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
475 sprintf(fmtstr,"%%%s",f);
478 fmtstr=HeapAlloc(GetProcessHeap(),0,strlen(f)+2);
479 sprintf(fmtstr,"%%%s",f);
480 f+=strlen(f); /*at \0*/
486 fmtstr=HEAP_strdupA(GetProcessHeap(),0,"%s");
489 LPSTR b = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz = 100);
491 argliststart=args+insertnr-1;
493 /* CMF - This makes a BIG assumption about va_list */
494 while (vsnprintf(b, sz, fmtstr, (va_list) argliststart) < 0) {
495 b = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, b, sz += 100);
497 for (x=b; *x; x++) ADD_TO_T(*x);
499 /* NULL args - copy formatstr
502 while ((lastf<f)&&(*lastf)) {
506 HeapFree(GetProcessHeap(),0,fmtstr);
508 case '0': /* Just stop processing format string */
512 case 'n': /* 16 bit version just outputs 'n' */
517 } else { /* '\n' or '\r' gets mapped to "\r\n" */
518 if(*f == '\n' || *f == '\r') {
522 if(*f++ == '\r' && *f == '\n')
532 talloced = strlen(target)+1;
533 if (nSize && talloced<nSize) {
534 target = (char*)HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,target,nSize);
536 TRACE("-- %s\n",debugstr_a(target));
537 if (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) {
538 /* nSize is the MINIMUM size */
539 HLOCAL16 h = LocalAlloc16(LPTR,talloced);
540 SEGPTR ptr = LocalLock16(h);
541 allocstring = PTR_SEG_TO_LIN( ptr );
542 memcpy( allocstring,target,talloced);
544 *((HLOCAL16*)lpBuffer) = h;
546 lstrcpynA(lpBuffer,target,nSize);
547 HeapFree(GetProcessHeap(),0,target);
548 if (from) HeapFree(GetProcessHeap(),0,from);
549 return (dwFlags & FORMAT_MESSAGE_ALLOCATE_BUFFER) ?
554 #endif /* __i386__ */