00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018 #include <ctype.h>
00019 #include <stdarg.h>
00020 #include <stdlib.h>
00021 #include <stdio.h>
00022 #include <string.h>
00023 #include <os2win.h>
00024
00025 #include "winnls.h"
00026
00027 #include <misc.h>
00028 #include <wine\unicode.h>
00029
00030
00031 #define DBG_LOCALLOG DBG_char
00032 #include "dbglocal.h"
00033
00034
00035
00036
00037
00038
00039 LPSTR WINAPI CharNextA( LPCSTR ptr )
00040 {
00041 dprintf2(("CharNextA %x", ptr));
00042 if (!*ptr) return (LPSTR)ptr;
00043 if (IsDBCSLeadByte( ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
00044 return (LPSTR)(ptr + 1);
00045 }
00046
00047
00048
00049
00050
00051 LPSTR WINAPI CharNextExA( WORD codepage, LPCSTR ptr, DWORD flags )
00052 {
00053 dprintf2(("CharNextExA %d %x %x", codepage, ptr, flags));
00054
00055 if (!*ptr) return (LPSTR)ptr;
00056 if (IsDBCSLeadByteEx( codepage, ptr[0] ) && ptr[1]) return (LPSTR)(ptr + 2);
00057 return (LPSTR)(ptr + 1);
00058 }
00059
00060
00061
00062
00063
00064 LPWSTR WINAPI CharNextExW( WORD codepage, LPCWSTR ptr, DWORD flags )
00065 {
00066 dprintf2(("CharNextExW %d %x %x", codepage, ptr, flags));
00067
00068 return NULL;
00069 }
00070
00071
00072
00073
00074
00075 LPWSTR WINAPI CharNextW(LPCWSTR x)
00076 {
00077 dprintf2(("CharNextW %x", x));
00078
00079 if (*x) x++;
00080
00081 return (LPWSTR)x;
00082 }
00083
00084
00085
00086
00087
00088 LPSTR WINAPI CharPrevA( LPCSTR start, LPCSTR ptr )
00089 {
00090 dprintf2(("CharPrevA %x %x", start, ptr));
00091
00092 while (*start && (start < ptr))
00093 {
00094 LPCSTR next = CharNextA( start );
00095 if (next >= ptr) break;
00096 start = next;
00097 }
00098 return (LPSTR)start;
00099 }
00100
00101
00102
00103
00104
00105 LPSTR WINAPI CharPrevExA( WORD codepage, LPCSTR start, LPCSTR ptr, DWORD flags )
00106 {
00107 dprintf2(("CharPrevExA %d %x %x %x", codepage, start, ptr, flags));
00108
00109 while (*start && (start < ptr))
00110 {
00111 LPCSTR next = CharNextExA( codepage, start, flags );
00112 if (next > ptr) break;
00113 start = next;
00114 }
00115 return (LPSTR)start;
00116 }
00117
00118
00119
00120
00121
00122 LPWSTR WINAPI CharPrevExW( WORD codepage, LPCWSTR start, LPCWSTR ptr, DWORD flags )
00123 {
00124
00125 dprintf2(("CharPrevExW %d %x %x %x", codepage, start, ptr, flags));
00126 return NULL;
00127 }
00128
00129
00130
00131
00132
00133 LPWSTR WINAPI CharPrevW(LPCWSTR start,LPCWSTR x)
00134 {
00135 dprintf2(("CharPrevW %x %x", start, x));
00136
00137 if (x>start) return (LPWSTR)(x-1);
00138 else return (LPWSTR)x;
00139 }
00140
00141
00142
00143
00144
00145 BOOL WINAPI CharToOemA( LPCSTR s, LPSTR d )
00146 {
00147 dprintf2(("CharToOemA %x %x", s, d));
00148 if ( !s || !d ) return TRUE;
00149 return CharToOemBuffA( s, d, strlen( s ) + 1 );
00150 }
00151
00152
00153
00154
00155
00156 BOOL WINAPI CharToOemBuffA( LPCSTR s, LPSTR d, DWORD len )
00157 {
00158 WCHAR *bufW;
00159
00160 dprintf2(("CharToOemBuffA %x %x %d", s, d, len));
00161 bufW = (WCHAR *)HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
00162 if( bufW )
00163 {
00164 MultiByteToWideChar( CP_ACP, 0, s, len, bufW, len );
00165 WideCharToMultiByte( CP_OEMCP, 0, bufW, len, d, len, NULL, NULL );
00166 HeapFree( GetProcessHeap(), 0, bufW );
00167 }
00168 return TRUE;
00169 }
00170
00171
00172
00173
00174
00175 BOOL WINAPI CharToOemBuffW( LPCWSTR s, LPSTR d, DWORD len )
00176 {
00177 dprintf2(("CharToOemBuffW %x %x %d", s, d, len));
00178
00179 if ( !s || !d ) return TRUE;
00180 WideCharToMultiByte( CP_OEMCP, 0, s, len, d, len, NULL, NULL );
00181 return TRUE;
00182 }
00183
00184
00185
00186
00187
00188 BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
00189 {
00190 return CharToOemBuffW( s, d, strlenW( s ) + 1 );
00191 }
00192
00193
00194
00195
00196
00197 BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
00198 {
00199 return OemToCharBuffA( s, d, strlen( s ) + 1 );
00200 }
00201
00202
00203
00204
00205
00206 BOOL WINAPI OemToCharBuffA( LPCSTR s, LPSTR d, DWORD len )
00207 {
00208 WCHAR *bufW;
00209
00210 dprintf2(("OemToCharBuffA %x %x %d", s, d, len));
00211
00212 bufW = (WCHAR *)HeapAlloc( GetProcessHeap(), 0, len * sizeof(WCHAR) );
00213 if( bufW )
00214 {
00215 MultiByteToWideChar( CP_OEMCP, 0, s, len, bufW, len );
00216 WideCharToMultiByte( CP_ACP, 0, bufW, len, d, len, NULL, NULL );
00217 HeapFree( GetProcessHeap(), 0, bufW );
00218 }
00219 return TRUE;
00220 }
00221
00222
00223
00224
00225
00226 BOOL WINAPI OemToCharBuffW( LPCSTR s, LPWSTR d, DWORD len )
00227 {
00228 dprintf2(("OemToCharBuffW %x %x %d", s, d, len));
00229
00230 MultiByteToWideChar( CP_OEMCP, 0, s, len, d, len );
00231 return TRUE;
00232 }
00233
00234
00235
00236
00237
00238 BOOL WINAPI OemToCharW( LPCSTR s, LPWSTR d )
00239 {
00240 return OemToCharBuffW( s, d, strlen( s ) + 1 );
00241 }
00242
00243
00244
00245
00246
00247
00248 LPSTR WINAPI CharLowerA(LPSTR x)
00249 {
00250 LPSTR s;
00251
00252 dprintf2(("CharLowerA %x", x));
00253
00254 if (HIWORD(x))
00255 {
00256 s=x;
00257 while (*s)
00258 {
00259 *s=tolower(*s);
00260 s++;
00261 }
00262 return x;
00263 }
00264 else return (LPSTR)tolower((char)(int)x);
00265 }
00266
00267
00268
00269
00270
00271
00272 LPSTR WINAPI CharUpperA(LPSTR x)
00273 {
00274 dprintf2(("CharUpperA %x", x));
00275
00276 if (HIWORD(x))
00277 {
00278 LPSTR s = x;
00279 while (*s)
00280 {
00281 *s=toupper(*s);
00282 s++;
00283 }
00284 return x;
00285 }
00286 return (LPSTR)toupper((char)(int)x);
00287 }
00288
00289
00290
00291
00292
00293 LPWSTR WINAPI CharLowerW(LPWSTR x)
00294 {
00295 dprintf2(("CharLowerW %x", x));
00296 if (HIWORD(x)) return strlwrW(x);
00297 else return (LPWSTR)((UINT)tolowerW(LOWORD(x)));
00298 }
00299
00300
00301
00302
00303
00304
00305 LPWSTR WINAPI CharUpperW(LPWSTR x)
00306 {
00307 dprintf2(("CharUpperW %x", x));
00308 if (HIWORD(x)) return struprW(x);
00309 else return (LPWSTR)((UINT)toupperW(LOWORD(x)));
00310 }
00311
00312
00313
00314
00315
00316
00317 DWORD WINAPI CharLowerBuffA( LPSTR str, DWORD len )
00318 {
00319 DWORD ret = len;
00320
00321 dprintf2(("CharLowerBuffA %x %d", str, len));
00322
00323 if (!str) return 0;
00324 for (; len; len--, str++) *str = tolower(*str);
00325 return ret;
00326 }
00327
00328
00329
00330
00331
00332 DWORD WINAPI CharLowerBuffW( LPWSTR str, DWORD len )
00333 {
00334 DWORD ret = len;
00335
00336 dprintf2(("CharLowerBuffW %x %d", str, len));
00337
00338 if (!str) return 0;
00339 for (; len; len--, str++) *str = tolowerW(*str);
00340 return ret;
00341 }
00342
00343
00344
00345
00346
00347
00348 DWORD WINAPI CharUpperBuffA( LPSTR str, DWORD len )
00349 {
00350 DWORD ret = len;
00351
00352 dprintf2(("CharUpperBuffA %x %d", str, len));
00353
00354 if (!str) return 0;
00355 for (; len; len--, str++) *str = toupper(*str);
00356 return ret;
00357 }
00358
00359
00360
00361
00362
00363 DWORD WINAPI CharUpperBuffW( LPWSTR str, DWORD len )
00364 {
00365 DWORD ret = len;
00366
00367 dprintf2(("CharUpperBuffW %x %d", str, len));
00368
00369 if (!str) return 0;
00370 for (; len; len--, str++) *str = toupperW(*str);
00371 return ret;
00372 }
00373
00374
00375
00376
00377
00378
00379 BOOL WINAPI IsCharLowerA(CHAR x)
00380 {
00381 dprintf2(("IsCharLowerA %x", x));
00382 return islower(x);
00383 }
00384
00385
00386
00387
00388
00389 BOOL WINAPI IsCharLowerW(WCHAR x)
00390 {
00391 dprintf2(("IsCharLowerW %x", x));
00392 return get_char_typeW(x) & C1_LOWER;
00393 }
00394
00395
00396
00397
00398
00399
00400 BOOL WINAPI IsCharUpperA(CHAR x)
00401 {
00402 dprintf2(("IsCharUpperA %x", x));
00403 return isupper(x);
00404 }
00405
00406
00407
00408
00409
00410 BOOL WINAPI IsCharUpperW(WCHAR x)
00411 {
00412 dprintf2(("IsCharUpperW %x", x));
00413 return get_char_typeW(x) & C1_UPPER;
00414 }
00415
00416
00417
00418
00419
00420 BOOL WINAPI IsCharAlphaNumericW(WCHAR x)
00421 {
00422 dprintf2(("IsCharAlphaNumericW %x", x));
00423 return get_char_typeW(x) & (C1_ALPHA|C1_DIGIT|C1_LOWER|C1_UPPER);
00424 }
00425
00426
00427
00428
00429
00430 BOOL WINAPI IsCharAlphaW(WCHAR x)
00431 {
00432 dprintf2(("IsCharAlphaW %x", x));
00433 return get_char_typeW(x) & (C1_ALPHA|C1_LOWER|C1_UPPER);
00434 }
00435
00436
00437 BOOL WIN32API IsCharAlphaA( CHAR x)
00438 {
00439 WCHAR wch;
00440
00441 dprintf(("USER32: IsCharAlphaA %x", x));
00442 MultiByteToWideChar(CP_ACP, 0, &x, 1, &wch, 1);
00443 return IsCharAlphaW(wch);
00444 }
00445
00446
00447 BOOL WIN32API IsCharAlphaNumericA( CHAR x)
00448 {
00449 dprintf(("USER32: IsCharAlphaNumericA %x", x));
00450 return (get_char_typeW(x) & C1_ALPHA) != 0;
00451 }
00452
00453