test: wstrings.c File Reference

Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

# wstrings.c File Reference

`#include "precomp.h"`

Go to the source code of this file.

## Defines

#define | LATIN_CAPITAL_LETTER_A_GRAVE (WCHAR)0xc0
#define | LATIN_CAPITAL_LETTER_THORN (WCHAR)0xde
#define | LATIN_SMALL_LETTER_SHARP_S (WCHAR)0xdf
#define | LATIN_SMALL_LETTER_Y_DIAERESIS (WCHAR)0xff
#define | DIVISION_SIGN (WCHAR)0xf7
#define | MULTIPLICATION_SIGN (WCHAR)0xd7
#define | WCTOA(wch) ((wch) & 0xff)
#define | IS_UNICODE_BLK1(wch) ((int)(wch) <= 0x00ff)

## Functions

LPWSTR WINAPI | CharLowerW (LPWSTR pwsz)
LPWSTR WINAPI | CharUpperW (LPWSTR pwsz)
LPWSTR WINAPI | CharNextW (LPCWSTR lpwCurrentChar)
LPWSTR WINAPI | CharPrevW (LPCWSTR lpwStart, LPCWSTR lpwCurrentChar)
DWORD WINAPI | CharLowerBuffW (LPWSTR pwsz, DWORD cwch)
DWORD WINAPI | CharUpperBuffW (LPWSTR pwsz, DWORD cwch)
BOOL WINAPI | IsCharLowerW (WCHAR wChar)
BOOL WINAPI | IsCharUpperW (WCHAR wChar)
BOOL WINAPI | IsCharAlphaNumericW (WCHAR wChar)
BOOL WINAPI | IsCharAlphaW (WCHAR wChar)

## Define Documentation

#define DIVISION_SIGN (WCHAR)0xf7

| Definition at line 23 of file wstrings.c.

#define IS_UNICODE_BLK1 | ( | wch |  | ) | ((int)(wch) <= 0x00ff)

| Definition at line 31 of file wstrings.c. Referenced by CharLowerBuffW(), CharUpperBuffW(), IsCharLowerW(), and IsCharUpperW().

#define LATIN_CAPITAL_LETTER_A_GRAVE (WCHAR)0xc0

| Definition at line 19 of file wstrings.c.

#define LATIN_CAPITAL_LETTER_THORN (WCHAR)0xde

| Definition at line 20 of file wstrings.c.

#define LATIN_SMALL_LETTER_SHARP_S (WCHAR)0xdf

| Definition at line 21 of file wstrings.c.

#define LATIN_SMALL_LETTER_Y_DIAERESIS (WCHAR)0xff

| Definition at line 22 of file wstrings.c.

#define MULTIPLICATION_SIGN (WCHAR)0xd7

| Definition at line 24 of file wstrings.c.

#define WCTOA | ( | wch |  | ) | ((wch) & 0xff)

| Definition at line 30 of file wstrings.c.

## Function Documentation

DWORD WINAPI CharLowerBuffW | ( | LPWSTR | pwsz,
|  | DWORD | cwch
| ) |

Definition at line 252 of file wstrings.c.

References DWORD, IS_UNICODE_BLK1, and IsCharUpperA().

Referenced by CharLowerBuffA(), CharLowerW(), ECInsertText(), and xxxLBInsertItem().

    00255 {
    00256     int cwchT;
    00257     DWORD i;
    00258
    00259     if (cwch == 0) {
    00260         return 0;
    00261     }
    00262
    00263     cwchT = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
    00264                 pwsz, cwch, pwsz, cwch);
    00265
    00266     if (cwchT != 0) {
    00267         return cwchT;
    00268     }
    00269
    00270     /*
    00271      * LCMapString failed!  The caller is not expecting failure,
    00272      * CharLowerBuffW does not have a failure indicator, so we
    00273      * convert the buffer to lower case as best we can.
    00274      */
    00275     RIPMSG1(RIP_WARNING, "CharLowerBuffW(%ls) failed", pwsz);
    00276
    00277     for (i=0; i < cwch; i++) {
    00278         if (IS_UNICODE_BLK1(pwsz[i]) && IsCharUpperA((char)pwsz[i])) {
    00279             pwsz[i] += 'a'-'A';
    00280         }
    00281     }
    00282
    00283     return cwch;
    00284 }

LPWSTR WINAPI CharLowerW | ( | LPWSTR | pwsz | ) |

Definition at line 49 of file wstrings.c.

References CharLowerBuffW(), IS_PTR, and NULL.

Referenced by FindMnemChar().

    00051 {
    00052     /*
    00053      * Early out for NULL string or '\0'
    00054      */
    00055     if (pwsz == NULL) {
    00056         return pwsz;
    00057     }
    00058
    00059     if (!IS_PTR(pwsz)) {
    00060         if (!LCMapStringW(
    00061                  LOCALE_USER_DEFAULT,
    00062                  LCMAP_LOWERCASE,
    00063                  (LPWSTR)&pwsz,
    00064                  1,
    00065                  (LPWSTR)&pwsz,
    00066                  1
    00067                  )) {
    00068             /*
    00069              * We don't expect LCMapString to fail!  The caller is not expecting
    00070              * failure, CharLowerW does not have a failure indicator, so we do
    00071              * nothing.
    00072              */
    00073             RIPMSG1(RIP_WARNING, "CharLowerW(%#p): LCMapString failed\n", pwsz);
    00074         }
    00075
    00076         return pwsz;
    00077     }
    00078
    00079     /*
    00080      * pwsz is a null-terminated string
    00081      */
    00082     CharLowerBuffW(pwsz, wcslen(pwsz)+1);
    00083     return pwsz;
    00084 }

LPWSTR WINAPI CharNextW | ( | LPCWSTR | lpwCurrentChar | ) |

Definition at line 154 of file wstrings.c.

Referenced by CompStrWToCharA(), and CompStrWToCharW().

    00156 {
    00157     WORD ctype3info;
    00158
    00159     if (*lpwCurrentChar) {
    00160         //
    00161         // Examine each code element.  Skip all combining elements.
    00162         //
    00163         while (*(++lpwCurrentChar)) {
    00164             if (!GetStringTypeW(
    00165                     CT_CTYPE3,
    00166                     lpwCurrentChar,
    00167                     1,
    00168                     &ctype3info)) {
    00169                 /*
    00170                  * GetStringTypeW failed!  The caller is not expecting failure,
    00171                  * CharNextW does not have a failure indicator, so just return
    00172                  * a pointer to the character we couldn't analyze.
    00173                  */
    00174                 RIPMSG2(RIP_WARNING, "CharNextW failed, L'\\x%.4x' at %#p",
    00175                         *lpwCurrentChar, lpwCurrentChar);
    00176                 break;
    00177             }
    00178             if (!((ctype3info & C3_NONSPACING) && (!(ctype3info & C3_ALPHA)))) {
    00179                 break;
    00180             }
    00181         }
    00182     }
    00183
    00184     return (LPWSTR)lpwCurrentChar;
    00185 }

LPWSTR WINAPI CharPrevW | ( | LPCWSTR | lpwStart,
|  | LPCWSTR | lpwCurrentChar
| ) |

Definition at line 203 of file wstrings.c.

    00206 {
    00207     WORD ctype3info;
    00208     LPWSTR lpwValidChar = (LPWSTR)lpwCurrentChar;
    00209
    00210
    00211     if (lpwCurrentChar > lpwStart) {
    00212         //
    00213         // Examine each code element.  Skip all combining elements.
    00214         //
    00215         while (lpwCurrentChar-- > lpwStart) {
    00216             if (!GetStringTypeW(
    00217                     CT_CTYPE3,
    00218                     lpwCurrentChar,
    00219                     1,
    00220                     &ctype3info)) {
    00221                 /*
    00222                  * GetStringTypeW failed!  The caller is not expecting failure,
    00223                  * CharPrevW does not have a failure indicator, so just return
    00224                  * a pointer to the character we couldn't analyze.
    00225                  */
    00226                 RIPMSG2(RIP_WARNING, "CharPrevW failed, L'\\x%.4x' at %#p",
    00227                         *lpwCurrentChar, lpwCurrentChar);
    00228                 break;
    00229             }
    00230             if (!((ctype3info & C3_NONSPACING) && (!(ctype3info & C3_ALPHA)))) {
    00231                 lpwValidChar = (LPWSTR)lpwCurrentChar;
    00232                 break;  // found non-combining code element
    00233             }
    00234         }
    00235     }
    00236
    00237     return (LPWSTR)lpwValidChar;
    00238 }

DWORD WINAPI CharUpperBuffW | ( | LPWSTR | pwsz,
|  | DWORD | cwch
| ) |

Definition at line 298 of file wstrings.c.

References DWORD, IS_UNICODE_BLK1, IsCharLowerA(), LATIN_SMALL_LETTER_SHARP_S, and LATIN_SMALL_LETTER_Y_DIAERESIS.

Referenced by CharUpperBuffA(), CharUpperW(), ECInsertText(), and xxxLBInsertItem().

    00301 {
    00302     int cwchT;
    00303     DWORD i;
    00304
    00305     if (cwch == 0) {
    00306         return 0;
    00307     }
    00308
    00309     cwchT = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
    00310                 pwsz, cwch, pwsz, cwch);
    00311
    00312     if (cwchT != 0) {
    00313         return cwchT;
    00314     }
    00315
    00316     /*
    00317      * LCMapString failed!  The caller is not expecting failure,
    00318      * CharUpperBuffW does not have a failure indicator, so we
    00319      * convert the buffer to upper case as best we can.
    00320      */
    00321     RIPMSG1(RIP_WARNING, "CharUpperBuffW(%ls) failed", pwsz);
    00322
    00323     for (i=0; i < cwch; i++) {
    00324         if (IS_UNICODE_BLK1(pwsz[i]) &&
    00325                 IsCharLowerA((char)pwsz[i]) &&
    00326                 (pwsz[i] != LATIN_SMALL_LETTER_SHARP_S) &&
    00327                 (pwsz[i] != LATIN_SMALL_LETTER_Y_DIAERESIS)) {
    00328             pwsz[i] += (WCHAR)('A'-'a');
    00329         }
    00330     }
    00331
    00332     return cwch;
    00333 }

LPWSTR WINAPI CharUpperW | ( | LPWSTR | pwsz | ) |

Definition at line 102 of file wstrings.c.

References CharUpperBuffW(), IS_PTR, and NULL.

    00104 {
    00105     /*
    00106      * Early out for NULL string or '\0'
    00107      */
    00108     if (pwsz == NULL) {
    00109         return pwsz;
    00110     }
    00111
    00112     if (!IS_PTR(pwsz)) {
    00113         if (!LCMapStringW(
    00114                  LOCALE_USER_DEFAULT,
    00115                  LCMAP_UPPERCASE,
    00116                  (LPWSTR)&pwsz,
    00117                  1,
    00118                  (LPWSTR)&pwsz,
    00119                  1
    00120                  )) {
    00121             /*
    00122              * We don't expect LCMapString to fail!  The caller is not expecting
    00123              * failure, CharLowerW does not have a failure indicator, so we do
    00124              * nothing.
    00125              */
    00126             RIPMSG1(RIP_WARNING, "CharUpperW(%#p): LCMapString failed", pwsz);
    00127         }
    00128
    00129         return pwsz;
    00130     }
    00131
    00132     /*
    00133      * pwsz is a null-terminated string
    00134      */
    00135     CharUpperBuffW(pwsz, wcslen(pwsz)+1);
    00136     return pwsz;
    00137 }

BOOL WINAPI IsCharAlphaNumericW | ( | WCHAR | wChar | ) |

Definition at line 427 of file wstrings.c.

References BOOL, FALSE, and TRUE.

    00429 {
    00430     WORD ctype1info;
    00431
    00432     if (!GetStringTypeW(CT_CTYPE1, &wChar, 1, &ctype1info)) {
    00433         //
    00434         // GetStringTypeW returned an error!  IsCharAlphaNumericW has no
    00435         // provision for returning an error...  The best we can do is to
    00436         // return FALSE
    00437         //
    00438         UserAssert(FALSE);
    00439         return FALSE;
    00440     }
    00441     //
    00442     // LATER 20 Feb 92 GregoryW
    00443     //    We may need to check ctype 3 info if we want to check for
    00444     //    digits other than ASCII '0'-'9' (such as Lao digits or
    00445     //    Tibetan digits, etc.).
    00446     //
    00447 #ifdef FE_SB // IsCharAlphaNumericW()
    00448     if (ctype1info & C1_ALPHA) {
    00449         WORD ctype3info = 0;
    00450         /*
    00451          * We don't want to return TRUE for halfwidth katakana.
    00452          * Katakana is linguistic character (C1_ALPHA), but it is not
    00453          * alphabet character.
    00454          */
    00455         if (!GetStringTypeW(CT_CTYPE3, &wChar, 1, &ctype3info)) {
    00456             UserAssert(FALSE);
    00457             /*
    00458              * Assume, it is alphabet character, because it has
    00459              * C1_ALPHA attribute.
    00460              */
    00461             return TRUE;
    00462         }
    00463
    00464         if (ctype3info & (C3_KATAKANA|C3_HIRAGANA)) {
    00465             /*
    00466              * This is 'Katakana'.
    00467              */
    00468             return FALSE;
    00469         } else {
    00470             return TRUE;
    00471         }
    00472     } else if (ctype1info & C1_DIGIT) {
    00473         return TRUE;
    00474     } else {
    00475         return FALSE;
    00476     }
    00477 #else
    00478     if ((ctype1info & C1_ALPHA) || (ctype1info & C1_DIGIT)) {
    00479         return TRUE;
    00480     } else {
    00481         return FALSE;
    00482     }
    00483 #endif // FE_SB
    00484 }

BOOL WINAPI IsCharAlphaW | ( | WCHAR | wChar | ) |

Definition at line 499 of file wstrings.c.

References BOOL, FALSE, and TRUE.

    00501 {
    00502     WORD ctype1info;
    00503
    00504     if (!GetStringTypeW(CT_CTYPE1, &wChar, 1, &ctype1info)) {
    00505         //
    00506         // GetStringTypeW returned an error!  IsCharAlphaW has no
    00507         // provision for returning an error...  The best we can do
    00508         // is to return FALSE
    00509         //
    00510         UserAssert(FALSE);
    00511         return FALSE;
    00512     }
    00513     if (ctype1info & C1_ALPHA) {
    00514 #ifdef FE_SB // IsCharAlphaA()
    00515         WORD ctype3info = 0;
    00516         /*
    00517          * We don't want to return TRUE for halfwidth katakana.
    00518          * Katakana is linguistic character (C1_ALPHA), but it is not
    00519          * alphabet character.
    00520          */
    00521         if (!GetStringTypeW(CT_CTYPE3, &wChar, 1, &ctype3info)) {
    00522             UserAssert(FALSE);
    00523             /*
    00524              * Assume, it is alphabet character, because it has
    00525              * C1_ALPHA attribute.
    00526              */
    00527             return TRUE;
    00528         }
    00529
    00530         if (ctype3info & (C3_KATAKANA|C3_HIRAGANA)) {
    00531             /*
    00532              * This is 'Katakana'.
    00533              */
    00534             return FALSE;
    00535         } else {
    00536             return TRUE;
    00537         }
    00538 #else
    00539         return TRUE;
    00540 #endif // FE_SB
    00541     } else {
    00542         return FALSE;
    00543     }
    00544 }

BOOL WINAPI IsCharLowerW | ( | WCHAR | wChar | ) |

Definition at line 348 of file wstrings.c.

References BOOL, CHAR, FALSE, IS_UNICODE_BLK1, IsCharLowerA(), and TRUE.

Referenced by ECInsertText().

    00350 {
    00351     WORD ctype1info;
    00352
    00353     if (GetStringTypeW(CT_CTYPE1, &wChar, 1, &ctype1info)) {
    00354         if (ctype1info & C1_LOWER) {
    00355             return TRUE;
    00356         } else {
    00357             return FALSE;
    00358         }
    00359     }
    00360
    00361     /*
    00362      * GetStringTypeW failed!  The caller is not expecting
    00363      * failure, IsCharLowerW does not have a failure indicator, so we
    00364      * determine the case as best we can.
    00365      */
    00366     RIPMSG1(RIP_WARNING, "IsCharLowerW(L'\\x%.4lx') failed", wChar);
    00367
    00368     if (IS_UNICODE_BLK1(wChar)) {
    00369         return IsCharLowerA((CHAR)wChar);
    00370     } else {
    00371         return FALSE;
    00372     }
    00373 }

BOOL WINAPI IsCharUpperW | ( | WCHAR | wChar | ) |

Definition at line 387 of file wstrings.c.

References BOOL, CHAR, FALSE, IS_UNICODE_BLK1, IsCharUpperA(), and TRUE.

    00389 {
    00390     WORD ctype1info;
    00391
    00392     if (GetStringTypeW(CT_CTYPE1, &wChar, 1, &ctype1info)) {
    00393         if (ctype1info & C1_UPPER) {
    00394             return TRUE;
    00395         } else {
    00396             return FALSE;
    00397         }
    00398     }
    00399
    00400     /*
    00401      * GetStringTypeW failed!  The caller is not expecting
    00402      * failure, IsCharLowerW does not have a failure indicator, so we
    00403      * determine the case as best we can.
    00404      */
    00405     RIPMSG1(RIP_WARNING, "IsCharUpper(L'\\x%.4lx') failed", wChar);
    00406
    00407     if (IS_UNICODE_BLK1(wChar)) {
    00408         return IsCharUpperA((CHAR)wChar);
    00409     } else {
    00410         return FALSE;
    00411     }
    00412 }