dlls/msvcrt/ctype.c

   1 /*
   2  * msvcrt.dll ctype functions
   3  *
   4  * Copyright 2000 Jon Griffiths
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <locale.h>
  22 #include "msvcrt.h"
  23 #include "winnls.h"
  24
  25 /* Some abbreviations to make the following table readable */
  26 #define _C_ _CONTROL
  27 #define _S_ _SPACE
  28 #define _P_ _PUNCT
  29 #define _D_ _DIGIT
  30 #define _H_ _HEX
  31 #define _U_ _UPPER
  32 #define _L_ _LOWER
  33
  34 WORD MSVCRT__ctype [257] = {
  35   0, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _S_|_C_, _S_|_C_,
  36   _S_|_C_, _S_|_C_, _S_|_C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_,
  37   _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _S_|_BLANK,
  38   _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_,
  39   _P_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_,
  40   _D_|_H_, _D_|_H_, _D_|_H_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _U_|_H_,
  41   _U_|_H_, _U_|_H_, _U_|_H_, _U_|_H_, _U_|_H_, _U_, _U_, _U_, _U_, _U_,
  42   _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_,
  43   _U_, _P_, _P_, _P_, _P_, _P_, _P_, _L_|_H_, _L_|_H_, _L_|_H_, _L_|_H_,
  44   _L_|_H_, _L_|_H_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_,
  45   _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _P_, _P_, _P_, _P_,
  46   _C_, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  47   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  48   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  49   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  50   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  51   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
  52 };
  53
  54 #if _MSVCR_VER <= 110
  55 # define B110 _BLANK
  56 #else
  57 # define B110 0
  58 #endif
  59
  60 #if _MSVCR_VER == 120
  61 # define D120 0
  62 #else
  63 # define D120 4
  64 #endif
  65
  66 #if _MSVCR_VER >= 140
  67 # define S140 _SPACE
  68 # define L140 _LOWER | 0x100
  69 # define C140 _CONTROL
  70 #else
  71 # define S140 0
  72 # define L140 0
  73 # define C140 0
  74 #endif
  75 WORD MSVCRT__wctype[257] =
  76 {
  77     0,
  78     /* 00 */
  79     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  80     0x0020, 0x0028 | B110, 0x0028, 0x0028, 0x0028, 0x0028, 0x0020, 0x0020,
  81     /* 10 */
  82     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  83     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  84     /* 20 */
  85     0x0048, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  86     0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  87     /* 30 */
  88     0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084,
  89     0x0084, 0x0084, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  90     /* 40 */
  91     0x0010, 0x0181, 0x0181, 0x0181, 0x0181, 0x0181, 0x0181, 0x0101,
  92     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
  93     /* 50 */
  94     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
  95     0x0101, 0x0101, 0x0101, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  96     /* 60 */
  97     0x0010, 0x0182, 0x0182, 0x0182, 0x0182, 0x0182, 0x0182, 0x0102,
  98     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
  99     /* 70 */
 100     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
 101     0x0102, 0x0102, 0x0102, 0x0010, 0x0010, 0x0010, 0x0010, 0x0020,
 102     /* 80 */
 103     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020 | S140, 0x0020, 0x0020,
 104     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
 105     /* 90 */
 106     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
 107     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
 108     /* a0 */
 109     0x0008 | B110, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
 110     0x0010, 0x0010, 0x0010 | L140, 0x0010, 0x0010, 0x0010 | C140, 0x0010, 0x0010,
 111     /* b0 */
 112     0x0010, 0x0010, 0x0010 | D120, 0x0010 | D120, 0x0010, 0x0010 | L140, 0x0010, 0x0010,
 113     0x0010, 0x0010 | D120, 0x0010 | L140, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
 114     /* c0 */
 115     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 116     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 117     /* d0 */
 118     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0010,
 119     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0102,
 120     /* e0 */
 121     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
 122     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
 123     /* f0 */
 124     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0010,
 125     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102
 126 };
 127
 128 WORD *MSVCRT__pwctype = MSVCRT__wctype + 1;
 129
 130 /*********************************************************************
 131  *              __p__pctype (MSVCRT.@)
 132  */
 133 unsigned short** CDECL __p__pctype(void)
 134 {
 135     return &get_locinfo()->pctype;
 136 }
 137
 138 /*********************************************************************
 139  *              __pctype_func (MSVCRT.@)
 140  */
 141 const unsigned short* CDECL __pctype_func(void)
 142 {
 143     return get_locinfo()->pctype;
 144 }
 145
 146 /*********************************************************************
 147  *              __p__pwctype (MSVCRT.@)
 148  */
 149 unsigned short** CDECL __p__pwctype(void)
 150 {
 151     return &MSVCRT__pwctype;
 152 }
 153
 154 /*********************************************************************
 155  *              __pwctype_func (MSVCRT.@)
 156  */
 157 const unsigned short* CDECL __pwctype_func(void)
 158 {
 159     return MSVCRT__pwctype;
 160 }
 161
 162 /*********************************************************************
 163  *              _isctype_l (MSVCRT.@)
 164  */
 165 int CDECL _isctype_l(int c, int type, _locale_t locale)
 166 {
 167   pthreadlocinfo locinfo;
 168
 169   if(!locale)
 170     locinfo = get_locinfo();
 171   else
 172     locinfo = locale->locinfo;
 173
 174   if (c >= -1 && c <= 255)
 175     return locinfo->pctype[c] & type;
 176
 177   if (locinfo->mb_cur_max != 1 && c > 0)
 178   {
 179     /* FIXME: Is there a faster way to do this? */
 180     WORD typeInfo;
 181     char convert[3], *pconv = convert;
 182
 183     if (locinfo->pctype[(UINT)c >> 8] & _LEADBYTE)
 184       *pconv++ = (UINT)c >> 8;
 185     *pconv++ = c & 0xff;
 186     *pconv = 0;
 187
 188     if (GetStringTypeExA(locinfo->lc_handle[LC_CTYPE],
 189                 CT_CTYPE1, convert, convert[1] ? 2 : 1, &typeInfo))
 190       return typeInfo & type;
 191   }
 192   return 0;
 193 }
 194
 195 /*********************************************************************
 196  *              _isctype (MSVCRT.@)
 197  */
 198 int CDECL _isctype(int c, int type)
 199 {
 200     return _isctype_l(c, type, NULL);
 201 }
 202
 203 /*********************************************************************
 204  *              _isalnum_l (MSVCRT.@)
 205  */
 206 int CDECL _isalnum_l(int c, _locale_t locale)
 207 {
 208   return _isctype_l( c, _ALPHA | _DIGIT, locale );
 209 }
 210
 211 /*********************************************************************
 212  *              isalnum (MSVCRT.@)
 213  */
 214 int CDECL isalnum(int c)
 215 {
 216   return _isctype( c, _ALPHA | _DIGIT );
 217 }
 218
 219 /*********************************************************************
 220  *              _isalpha_l (MSVCRT.@)
 221  */
 222 int CDECL _isalpha_l(int c, _locale_t locale)
 223 {
 224   return _isctype_l( c, _ALPHA, locale );
 225 }
 226
 227 /*********************************************************************
 228  *              isalpha (MSVCRT.@)
 229  */
 230 int CDECL isalpha(int c)
 231 {
 232   return _isctype( c, _ALPHA );
 233 }
 234
 235 /*********************************************************************
 236  *              _iscntrl_l (MSVCRT.@)
 237  */
 238 int CDECL _iscntrl_l(int c, _locale_t locale)
 239 {
 240   return _isctype_l( c, _CONTROL, locale );
 241 }
 242
 243 /*********************************************************************
 244  *              iscntrl (MSVCRT.@)
 245  */
 246 int CDECL iscntrl(int c)
 247 {
 248   return _isctype( c, _CONTROL );
 249 }
 250
 251 /*********************************************************************
 252  *              _isdigit_l (MSVCRT.@)
 253  */
 254 int CDECL _isdigit_l(int c, _locale_t locale)
 255 {
 256   return _isctype_l( c, _DIGIT, locale );
 257 }
 258
 259 /*********************************************************************
 260  *              isdigit (MSVCRT.@)
 261  */
 262 int CDECL isdigit(int c)
 263 {
 264   return _isctype( c, _DIGIT );
 265 }
 266
 267 /*********************************************************************
 268  *              _isgraph_l (MSVCRT.@)
 269  */
 270 int CDECL _isgraph_l(int c, _locale_t locale)
 271 {
 272   return _isctype_l( c, _ALPHA | _DIGIT | _PUNCT, locale );
 273 }
 274
 275 /*********************************************************************
 276  *              isgraph (MSVCRT.@)
 277  */
 278 int CDECL isgraph(int c)
 279 {
 280   return _isctype( c, _ALPHA | _DIGIT | _PUNCT );
 281 }
 282
 283 /*********************************************************************
 284  *              _isleadbyte_l (MSVCRT.@)
 285  */
 286 int CDECL _isleadbyte_l(int c, _locale_t locale)
 287 {
 288   return _isctype_l( c, _LEADBYTE, locale );
 289 }
 290
 291 /*********************************************************************
 292  *              isleadbyte (MSVCRT.@)
 293  */
 294 int CDECL isleadbyte(int c)
 295 {
 296   return _isctype( c, _LEADBYTE );
 297 }
 298
 299 /*********************************************************************
 300  *              _islower_l (MSVCRT.@)
 301  */
 302 int CDECL _islower_l(int c, _locale_t locale)
 303 {
 304   return _isctype_l( c, _LOWER, locale );
 305 }
 306
 307 /*********************************************************************
 308  *              islower (MSVCRT.@)
 309  */
 310 int CDECL islower(int c)
 311 {
 312   return _isctype( c, _LOWER );
 313 }
 314
 315 /*********************************************************************
 316  *              _isprint_l (MSVCRT.@)
 317  */
 318 int CDECL _isprint_l(int c, _locale_t locale)
 319 {
 320   return _isctype_l( c, _ALPHA | _DIGIT | _BLANK | _PUNCT, locale );
 321 }
 322
 323 /*********************************************************************
 324  *              isprint (MSVCRT.@)
 325  */
 326 int CDECL isprint(int c)
 327 {
 328   return _isctype( c, _ALPHA | _DIGIT | _BLANK | _PUNCT );
 329 }
 330
 331 /*********************************************************************
 332  *              ispunct (MSVCRT.@)
 333  */
 334 int CDECL ispunct(int c)
 335 {
 336   return _isctype( c, _PUNCT );
 337 }
 338
 339 /*********************************************************************
 340  *              _ispunct_l (MSVCR80.@)
 341  */
 342 int CDECL _ispunct_l(int c, _locale_t locale)
 343 {
 344   return _isctype_l( c, _PUNCT, locale );
 345 }
 346
 347 /*********************************************************************
 348  *              _isspace_l (MSVCRT.@)
 349  */
 350 int CDECL _isspace_l(int c, _locale_t locale)
 351 {
 352   return _isctype_l( c, _SPACE, locale );
 353 }
 354
 355 /*********************************************************************
 356  *              isspace (MSVCRT.@)
 357  */
 358 int CDECL isspace(int c)
 359 {
 360   return _isctype( c, _SPACE );
 361 }
 362
 363 /*********************************************************************
 364  *              _isupper_l (MSVCRT.@)
 365  */
 366 int CDECL _isupper_l(int c, _locale_t locale)
 367 {
 368   return _isctype_l( c, _UPPER, locale );
 369 }
 370
 371 /*********************************************************************
 372  *              isupper (MSVCRT.@)
 373  */
 374 int CDECL isupper(int c)
 375 {
 376   return _isctype( c, _UPPER );
 377 }
 378
 379 /*********************************************************************
 380  *              _isxdigit_l (MSVCRT.@)
 381  */
 382 int CDECL _isxdigit_l(int c, _locale_t locale)
 383 {
 384   return _isctype_l( c, _HEX, locale );
 385 }
 386
 387 /*********************************************************************
 388  *              isxdigit (MSVCRT.@)
 389  */
 390 int CDECL isxdigit(int c)
 391 {
 392   return _isctype( c, _HEX );
 393 }
 394
 395 /*********************************************************************
 396  *              _isblank_l (MSVCRT.@)
 397  */
 398 int CDECL _isblank_l(int c, _locale_t locale)
 399 {
 400   return c == '\t' || _isctype_l( c, _BLANK, locale );
 401 }
 402
 403 /*********************************************************************
 404  *              isblank (MSVCRT.@)
 405  */
 406 int CDECL isblank(int c)
 407 {
 408   return c == '\t' || _isctype( c, _BLANK );
 409 }
 410
 411 /*********************************************************************
 412  *              __isascii (MSVCRT.@)
 413  */
 414 int CDECL __isascii(int c)
 415 {
 416   return ((unsigned)c < 0x80);
 417 }
 418
 419 /*********************************************************************
 420  *              __toascii (MSVCRT.@)
 421  */
 422 int CDECL __toascii(int c)
 423 {
 424   return (unsigned)c & 0x7f;
 425 }
 426
 427 /*********************************************************************
 428  *              iswascii (MSVCRT.@)
 429  *
 430  */
 431 int CDECL iswascii(wchar_t c)
 432 {
 433   return ((unsigned)c < 0x80);
 434 }
 435
 436 /*********************************************************************
 437  *              __iscsym (MSVCRT.@)
 438  */
 439 int CDECL __iscsym(int c)
 440 {
 441   return (c < 127 && (isalnum(c) || c == '_'));
 442 }
 443
 444 /*********************************************************************
 445  *              __iscsymf (MSVCRT.@)
 446  */
 447 int CDECL __iscsymf(int c)
 448 {
 449   return (c < 127 && (isalpha(c) || c == '_'));
 450 }
 451
 452 /*********************************************************************
 453  *              _toupper_l (MSVCRT.@)
 454  */
 455 int CDECL _toupper_l(int c, _locale_t locale)
 456 {
 457     pthreadlocinfo locinfo;
 458     unsigned char str[2], *p = str, ret[2];
 459
 460     if(!locale)
 461         locinfo = get_locinfo();
 462     else
 463         locinfo = locale->locinfo;
 464
 465     if((unsigned)c < 256)
 466         return locinfo->pcumap[c];
 467
 468     if(locinfo->pctype[(c>>8)&255] & _LEADBYTE)
 469         *p++ = (c>>8) & 255;
 470     else {
 471         *_errno() = EILSEQ;
 472         str[1] = 0;
 473     }
 474     *p++ = c & 255;
 475
 476     switch(__crtLCMapStringA(locinfo->lc_handle[LC_CTYPE], LCMAP_UPPERCASE,
 477                 (char*)str, p-str, (char*)ret, 2, locinfo->lc_codepage, 0))
 478     {
 479     case 0:
 480         return c;
 481     case 1:
 482         return ret[0];
 483     default:
 484         return ret[0] + (ret[1]<<8);
 485     }
 486 }
 487
 488 /*********************************************************************
 489  *              toupper (MSVCRT.@)
 490  */
 491 int CDECL toupper(int c)
 492 {
 493     if(initial_locale)
 494         return c>='a' && c<='z' ? c-'a'+'A' : c;
 495     return _toupper_l(c, NULL);
 496 }
 497
 498 /*********************************************************************
 499  *              _toupper (MSVCRT.@)
 500  */
 501 int CDECL _toupper(int c)
 502 {
 503     return c - 0x20;  /* sic */
 504 }
 505
 506 /*********************************************************************
 507  *              _tolower_l (MSVCRT.@)
 508  */
 509 int CDECL _tolower_l(int c, _locale_t locale)
 510 {
 511     pthreadlocinfo locinfo;
 512     unsigned char str[2], *p = str, ret[2];
 513
 514     if(!locale)
 515         locinfo = get_locinfo();
 516     else
 517         locinfo = locale->locinfo;
 518
 519     if((unsigned)c < 256)
 520         return locinfo->pclmap[c];
 521
 522     if(locinfo->pctype[(c>>8)&255] & _LEADBYTE)
 523         *p++ = (c>>8) & 255;
 524     else {
 525         *_errno() = EILSEQ;
 526         str[1] = 0;
 527     }
 528     *p++ = c & 255;
 529
 530     switch(__crtLCMapStringA(locinfo->lc_handle[LC_CTYPE], LCMAP_LOWERCASE,
 531                 (char*)str, p-str, (char*)ret, 2, locinfo->lc_codepage, 0))
 532     {
 533     case 0:
 534         return c;
 535     case 1:
 536         return ret[0];
 537     default:
 538         return ret[0] + (ret[1]<<8);
 539     }
 540 }
 541
 542 /*********************************************************************
 543  *              tolower (MSVCRT.@)
 544  */
 545 int CDECL tolower(int c)
 546 {
 547     if(initial_locale)
 548         return c>='A' && c<='Z' ? c-'A'+'a' : c;
 549     return _tolower_l(c, NULL);
 550 }
 551
 552 /*********************************************************************
 553  *              _tolower (MSVCRT.@)
 554  */
 555 int CDECL _tolower(int c)
 556 {
 557     return c + 0x20;  /* sic */
 558 }
 559
 560 #if _MSVCR_VER>=120
 561 /*********************************************************************
 562  *              wctype (MSVCR120.@)
 563  */
 564 unsigned short __cdecl wctype(const char *property)
 565 {
 566     static const struct {
 567         const char *name;
 568         unsigned short mask;
 569     } properties[] = {
 570         { "alnum", _DIGIT|_ALPHA },
 571         { "alpha", _ALPHA },
 572         { "cntrl", _CONTROL },
 573         { "digit", _DIGIT },
 574         { "graph", _DIGIT|_PUNCT|_ALPHA },
 575         { "lower", _LOWER },
 576         { "print", _DIGIT|_PUNCT|_BLANK|_ALPHA },
 577         { "punct", _PUNCT },
 578         { "space", _SPACE },
 579         { "upper", _UPPER },
 580         { "xdigit", _HEX }
 581     };
 582     unsigned int i;
 583
 584     for(i=0; i<ARRAY_SIZE(properties); i++)
 585         if(!strcmp(property, properties[i].name))
 586             return properties[i].mask;
 587
 588     return 0;
 589 }
 590 #endif