Main Page   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

char.cpp

Go to the documentation of this file.
00001 /* $Id: char.cpp,v 1.16 2001/07/28 12:57:57 sandervl Exp $ */
00002 
00003 /*
00004  * USER string functions
00005  *
00006  * Based on WINE code (dlls\user\lstr.c)
00007  *
00008  * Copyright 1993 Yngvi Sigurjonsson (yngvi@hafro.is)
00009  * Copyright 1996 Alexandre Julliard
00010  * Copyright 1996 Marcus Meissner
00011  *
00012  *
00013  * Project Odin Software License can be found in LICENSE.TXT
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  *           CharNextA   (USER32.@)
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  *           CharNextExA   (USER32.@)
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  *           CharNextExW   (USER32.@)
00063  */
00064 LPWSTR WINAPI CharNextExW( WORD codepage, LPCWSTR ptr, DWORD flags )
00065 {
00066     dprintf2(("CharNextExW %d %x %x", codepage, ptr, flags));
00067     /* doesn't make sense, there are no codepages for Unicode */
00068     return NULL;
00069 }
00070 
00071 
00072 /***********************************************************************
00073  *           CharNextW   (USER32.@)
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  *           CharPrevA   (USER32.@)
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  *           CharPrevExA   (USER32.@)
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  *           CharPrevExW   (USER32.@)
00121  */
00122 LPWSTR WINAPI CharPrevExW( WORD codepage, LPCWSTR start, LPCWSTR ptr, DWORD flags )
00123 {
00124     /* doesn't make sense, there are no codepages for Unicode */
00125     dprintf2(("CharPrevExW %d %x %x %x", codepage, start, ptr, flags));
00126     return NULL;
00127 }
00128 
00129 
00130 /***********************************************************************
00131  *           CharPrevW   (USER32.@)
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  *           CharToOemA   (USER32.@)
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  *           CharToOemBuffA   (USER32.@)
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  *           CharToOemBuffW   (USER32.@)
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  *           CharToOemW   (USER32.@)
00187  */
00188 BOOL WINAPI CharToOemW( LPCWSTR s, LPSTR d )
00189 {
00190     return CharToOemBuffW( s, d, strlenW( s ) + 1 );
00191 }
00192 
00193 
00194 /***********************************************************************
00195  *           OemToCharA   (USER32.@)
00196  */
00197 BOOL WINAPI OemToCharA( LPCSTR s, LPSTR d )
00198 {
00199     return OemToCharBuffA( s, d, strlen( s ) + 1 );
00200 }
00201 
00202 
00203 /***********************************************************************
00204  *           OemToCharBuffA   (USER32.@)
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  *           OemToCharBuffW   (USER32.@)
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  *           OemToCharW   (USER32.@)
00237  */
00238 BOOL WINAPI OemToCharW( LPCSTR s, LPWSTR d )
00239 {
00240     return OemToCharBuffW( s, d, strlen( s ) + 1 );
00241 }
00242 
00243 
00244 /***********************************************************************
00245  *           CharLowerA   (USER32.@)
00246  * FIXME: handle current locale
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  *           CharUpperA   (USER32.@)
00270  * FIXME: handle current locale
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  *           CharLowerW   (USER32.@)
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  *           CharUpperW   (USER32.@)
00303  * FIXME: handle current locale
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  *           CharLowerBuffA   (USER32.@)
00315  * FIXME: handle current locale
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; /* YES */
00324     for (; len; len--, str++) *str = tolower(*str);
00325     return ret;
00326 }
00327 
00328 
00329 /***********************************************************************
00330  *           CharLowerBuffW   (USER32.@)
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; /* YES */
00339     for (; len; len--, str++) *str = tolowerW(*str);
00340     return ret;
00341 }
00342 
00343 
00344 /***********************************************************************
00345  *           CharUpperBuffA   (USER32.@)
00346  * FIXME: handle current locale
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; /* YES */
00355     for (; len; len--, str++) *str = toupper(*str);
00356     return ret;
00357 }
00358 
00359 
00360 /***********************************************************************
00361  *           CharUpperBuffW   (USER32.@)
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; /* YES */
00370     for (; len; len--, str++) *str = toupperW(*str);
00371     return ret;
00372 }
00373 
00374 
00375 /***********************************************************************
00376  *           IsCharLowerA   (USER.436) (USER32.@)
00377  * FIXME: handle current locale
00378  */
00379 BOOL WINAPI IsCharLowerA(CHAR x)
00380 {
00381     dprintf2(("IsCharLowerA %x", x));
00382     return islower(x);
00383 }
00384 
00385 
00386 /***********************************************************************
00387  *           IsCharLowerW   (USER32.@)
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  *           IsCharUpperA   (USER.435) (USER32.@)
00398  * FIXME: handle current locale
00399  */
00400 BOOL WINAPI IsCharUpperA(CHAR x)
00401 {
00402     dprintf2(("IsCharUpperA %x", x));
00403     return isupper(x);
00404 }
00405 
00406 
00407 /***********************************************************************
00408  *           IsCharUpperW   (USER32.@)
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  *           IsCharAlphaNumericW   (USER32.@)
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  *           IsCharAlphaW   (USER32.@)
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 //******************************************************************************

Generated on Wed Jan 23 23:17:25 2002 for ODIN-user32 by doxygen1.2.11.1 written by Dimitri van Heesch, © 1997-2001