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 "msvcrt.h"
  22 #include "winnls.h"
  23
  24 /* Some abbreviations to make the following table readable */
  25 #define _C_ MSVCRT__CONTROL
  26 #define _S_ MSVCRT__SPACE
  27 #define _P_ MSVCRT__PUNCT
  28 #define _D_ MSVCRT__DIGIT
  29 #define _H_ MSVCRT__HEX
  30 #define _U_ MSVCRT__UPPER
  31 #define _L_ MSVCRT__LOWER
  32
  33 WORD MSVCRT__ctype [257] = {
  34   0, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _S_|_C_, _S_|_C_,
  35   _S_|_C_, _S_|_C_, _S_|_C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_,
  36   _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _C_, _S_|MSVCRT__BLANK,
  37   _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _P_,
  38   _P_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_, _D_|_H_,
  39   _D_|_H_, _D_|_H_, _D_|_H_, _P_, _P_, _P_, _P_, _P_, _P_, _P_, _U_|_H_,
  40   _U_|_H_, _U_|_H_, _U_|_H_, _U_|_H_, _U_|_H_, _U_, _U_, _U_, _U_, _U_,
  41   _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_, _U_,
  42   _U_, _P_, _P_, _P_, _P_, _P_, _P_, _L_|_H_, _L_|_H_, _L_|_H_, _L_|_H_,
  43   _L_|_H_, _L_|_H_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_,
  44   _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _L_, _P_, _P_, _P_, _P_,
  45   _C_, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
  46   0, 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
  51 };
  52
  53 #if _MSVCR_VER <= 110
  54 # define B110 MSVCRT__BLANK
  55 #else
  56 # define B110 0
  57 #endif
  58
  59 #if _MSVCR_VER == 120
  60 # define D120 0
  61 #else
  62 # define D120 4
  63 #endif
  64
  65 #if _MSVCR_VER >= 140
  66 # define S140 MSVCRT__SPACE
  67 # define L140 MSVCRT__LOWER | 0x100
  68 # define C140 MSVCRT__CONTROL
  69 #else
  70 # define S140 0
  71 # define L140 0
  72 # define C140 0
  73 #endif
  74 WORD MSVCRT__wctype[257] =
  75 {
  76     0,
  77     /* 00 */
  78     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  79     0x0020, 0x0028 | B110, 0x0028, 0x0028, 0x0028, 0x0028, 0x0020, 0x0020,
  80     /* 10 */
  81     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  82     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
  83     /* 20 */
  84     0x0048, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  85     0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  86     /* 30 */
  87     0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084, 0x0084,
  88     0x0084, 0x0084, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  89     /* 40 */
  90     0x0010, 0x0181, 0x0181, 0x0181, 0x0181, 0x0181, 0x0181, 0x0101,
  91     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
  92     /* 50 */
  93     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
  94     0x0101, 0x0101, 0x0101, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
  95     /* 60 */
  96     0x0010, 0x0182, 0x0182, 0x0182, 0x0182, 0x0182, 0x0182, 0x0102,
  97     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
  98     /* 70 */
  99     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
 100     0x0102, 0x0102, 0x0102, 0x0010, 0x0010, 0x0010, 0x0010, 0x0020,
 101     /* 80 */
 102     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020 | S140, 0x0020, 0x0020,
 103     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
 104     /* 90 */
 105     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
 106     0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020, 0x0020,
 107     /* a0 */
 108     0x0008 | B110, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
 109     0x0010, 0x0010, 0x0010 | L140, 0x0010, 0x0010, 0x0010 | C140, 0x0010, 0x0010,
 110     /* b0 */
 111     0x0010, 0x0010, 0x0010 | D120, 0x0010 | D120, 0x0010, 0x0010 | L140, 0x0010, 0x0010,
 112     0x0010, 0x0010 | D120, 0x0010 | L140, 0x0010, 0x0010, 0x0010, 0x0010, 0x0010,
 113     /* c0 */
 114     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 115     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101,
 116     /* d0 */
 117     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0010,
 118     0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0101, 0x0102,
 119     /* e0 */
 120     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
 121     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102,
 122     /* f0 */
 123     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0010,
 124     0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102, 0x0102
 125 };
 126
 127 WORD *MSVCRT__pwctype = MSVCRT__wctype + 1;
 128
 129 /*********************************************************************
 130  *              __p__pctype (MSVCRT.@)
 131  */
 132 unsigned short** CDECL MSVCRT___p__pctype(void)
 133 {
 134     return &get_locinfo()->pctype;
 135 }
 136
 137 /*********************************************************************
 138  *              __pctype_func (MSVCRT.@)
 139  */
 140 const unsigned short* CDECL MSVCRT___pctype_func(void)
 141 {
 142     return get_locinfo()->pctype;
 143 }
 144
 145 /*********************************************************************
 146  *              _isctype_l (MSVCRT.@)
 147  */
 148 int CDECL MSVCRT__isctype_l(int c, int type, MSVCRT__locale_t locale)
 149 {
 150   MSVCRT_pthreadlocinfo locinfo;
 151
 152   if(!locale)
 153     locinfo = get_locinfo();
 154   else
 155     locinfo = locale->locinfo;
 156
 157   if (c >= -1 && c <= 255)
 158     return locinfo->pctype[c] & type;
 159
 160   if (locinfo->mb_cur_max != 1 && c > 0)
 161   {
 162     /* FIXME: Is there a faster way to do this? */
 163     WORD typeInfo;
 164     char convert[3], *pconv = convert;
 165
 166     if (locinfo->pctype[(UINT)c >> 8] & MSVCRT__LEADBYTE)
 167       *pconv++ = (UINT)c >> 8;
 168     *pconv++ = c & 0xff;
 169     *pconv = 0;
 170
 171     if (GetStringTypeExA(locinfo->lc_handle[MSVCRT_LC_CTYPE],
 172                 CT_CTYPE1, convert, convert[1] ? 2 : 1, &typeInfo))
 173       return typeInfo & type;
 174   }
 175   return 0;
 176 }
 177
 178 /*********************************************************************
 179  *              _isctype (MSVCRT.@)
 180  */
 181 int CDECL MSVCRT__isctype(int c, int type)
 182 {
 183     return MSVCRT__isctype_l(c, type, NULL);
 184 }
 185
 186 /*********************************************************************
 187  *              _isalnum_l (MSVCRT.@)
 188  */
 189 int CDECL MSVCRT__isalnum_l(int c, MSVCRT__locale_t locale)
 190 {
 191   return MSVCRT__isctype_l( c, MSVCRT__ALPHA | MSVCRT__DIGIT, locale );
 192 }
 193
 194 /*********************************************************************
 195  *              isalnum (MSVCRT.@)
 196  */
 197 int CDECL MSVCRT_isalnum(int c)
 198 {
 199   return MSVCRT__isctype( c, MSVCRT__ALPHA | MSVCRT__DIGIT );
 200 }
 201
 202 /*********************************************************************
 203  *              _isalpha_l (MSVCRT.@)
 204  */
 205 int CDECL MSVCRT__isalpha_l(int c, MSVCRT__locale_t locale)
 206 {
 207   return MSVCRT__isctype_l( c, MSVCRT__ALPHA, locale );
 208 }
 209
 210 /*********************************************************************
 211  *              isalpha (MSVCRT.@)
 212  */
 213 int CDECL MSVCRT_isalpha(int c)
 214 {
 215   return MSVCRT__isctype( c, MSVCRT__ALPHA );
 216 }
 217
 218 /*********************************************************************
 219  *              _iscntrl_l (MSVCRT.@)
 220  */
 221 int CDECL MSVCRT__iscntrl_l(int c, MSVCRT__locale_t locale)
 222 {
 223   return MSVCRT__isctype_l( c, MSVCRT__CONTROL, locale );
 224 }
 225
 226 /*********************************************************************
 227  *              iscntrl (MSVCRT.@)
 228  */
 229 int CDECL MSVCRT_iscntrl(int c)
 230 {
 231   return MSVCRT__isctype( c, MSVCRT__CONTROL );
 232 }
 233
 234 /*********************************************************************
 235  *              _isdigit_l (MSVCRT.@)
 236  */
 237 int CDECL MSVCRT__isdigit_l(int c, MSVCRT__locale_t locale)
 238 {
 239   return MSVCRT__isctype_l( c, MSVCRT__DIGIT, locale );
 240 }
 241
 242 /*********************************************************************
 243  *              isdigit (MSVCRT.@)
 244  */
 245 int CDECL MSVCRT_isdigit(int c)
 246 {
 247   return MSVCRT__isctype( c, MSVCRT__DIGIT );
 248 }
 249
 250 /*********************************************************************
 251  *              _isgraph_l (MSVCRT.@)
 252  */
 253 int CDECL MSVCRT__isgraph_l(int c, MSVCRT__locale_t locale)
 254 {
 255   return MSVCRT__isctype_l( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__PUNCT, locale );
 256 }
 257
 258 /*********************************************************************
 259  *              isgraph (MSVCRT.@)
 260  */
 261 int CDECL MSVCRT_isgraph(int c)
 262 {
 263   return MSVCRT__isctype( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__PUNCT );
 264 }
 265
 266 /*********************************************************************
 267  *              _isleadbyte_l (MSVCRT.@)
 268  */
 269 int CDECL MSVCRT__isleadbyte_l(int c, MSVCRT__locale_t locale)
 270 {
 271   return MSVCRT__isctype_l( c, MSVCRT__LEADBYTE, locale );
 272 }
 273
 274 /*********************************************************************
 275  *              isleadbyte (MSVCRT.@)
 276  */
 277 int CDECL MSVCRT_isleadbyte(int c)
 278 {
 279   return MSVCRT__isctype( c, MSVCRT__LEADBYTE );
 280 }
 281
 282 /*********************************************************************
 283  *              _islower_l (MSVCRT.@)
 284  */
 285 int CDECL MSVCRT__islower_l(int c, MSVCRT__locale_t locale)
 286 {
 287   return MSVCRT__isctype_l( c, MSVCRT__LOWER, locale );
 288 }
 289
 290 /*********************************************************************
 291  *              islower (MSVCRT.@)
 292  */
 293 int CDECL MSVCRT_islower(int c)
 294 {
 295   return MSVCRT__isctype( c, MSVCRT__LOWER );
 296 }
 297
 298 /*********************************************************************
 299  *              _isprint_l (MSVCRT.@)
 300  */
 301 int CDECL MSVCRT__isprint_l(int c, MSVCRT__locale_t locale)
 302 {
 303   return MSVCRT__isctype_l( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__BLANK | MSVCRT__PUNCT, locale );
 304 }
 305
 306 /*********************************************************************
 307  *              isprint (MSVCRT.@)
 308  */
 309 int CDECL MSVCRT_isprint(int c)
 310 {
 311   return MSVCRT__isctype( c, MSVCRT__ALPHA | MSVCRT__DIGIT | MSVCRT__BLANK | MSVCRT__PUNCT );
 312 }
 313
 314 /*********************************************************************
 315  *              ispunct (MSVCRT.@)
 316  */
 317 int CDECL MSVCRT_ispunct(int c)
 318 {
 319   return MSVCRT__isctype( c, MSVCRT__PUNCT );
 320 }
 321
 322 /*********************************************************************
 323  *              _ispunct_l (MSVCR80.@)
 324  */
 325 int CDECL MSVCRT__ispunct_l(int c, MSVCRT__locale_t locale)
 326 {
 327   return MSVCRT__isctype_l( c, MSVCRT__PUNCT, locale );
 328 }
 329
 330 /*********************************************************************
 331  *              _isspace_l (MSVCRT.@)
 332  */
 333 int CDECL MSVCRT__isspace_l(int c, MSVCRT__locale_t locale)
 334 {
 335   return MSVCRT__isctype_l( c, MSVCRT__SPACE, locale );
 336 }
 337
 338 /*********************************************************************
 339  *              isspace (MSVCRT.@)
 340  */
 341 int CDECL MSVCRT_isspace(int c)
 342 {
 343   return MSVCRT__isctype( c, MSVCRT__SPACE );
 344 }
 345
 346 /*********************************************************************
 347  *              _isupper_l (MSVCRT.@)
 348  */
 349 int CDECL MSVCRT__isupper_l(int c, MSVCRT__locale_t locale)
 350 {
 351   return MSVCRT__isctype_l( c, MSVCRT__UPPER, locale );
 352 }
 353
 354 /*********************************************************************
 355  *              isupper (MSVCRT.@)
 356  */
 357 int CDECL MSVCRT_isupper(int c)
 358 {
 359   return MSVCRT__isctype( c, MSVCRT__UPPER );
 360 }
 361
 362 /*********************************************************************
 363  *              _isxdigit_l (MSVCRT.@)
 364  */
 365 int CDECL MSVCRT__isxdigit_l(int c, MSVCRT__locale_t locale)
 366 {
 367   return MSVCRT__isctype_l( c, MSVCRT__HEX, locale );
 368 }
 369
 370 /*********************************************************************
 371  *              isxdigit (MSVCRT.@)
 372  */
 373 int CDECL MSVCRT_isxdigit(int c)
 374 {
 375   return MSVCRT__isctype( c, MSVCRT__HEX );
 376 }
 377
 378 /*********************************************************************
 379  *              _isblank_l (MSVCRT.@)
 380  */
 381 int CDECL MSVCRT__isblank_l(int c, MSVCRT__locale_t locale)
 382 {
 383   return c == '\t' || MSVCRT__isctype_l( c, MSVCRT__BLANK, locale );
 384 }
 385
 386 /*********************************************************************
 387  *              isblank (MSVCRT.@)
 388  */
 389 int CDECL MSVCRT_isblank(int c)
 390 {
 391   return c == '\t' || MSVCRT__isctype( c, MSVCRT__BLANK );
 392 }
 393
 394 /*********************************************************************
 395  *              __isascii (MSVCRT.@)
 396  */
 397 int CDECL MSVCRT___isascii(int c)
 398 {
 399   return ((unsigned)c < 0x80);
 400 }
 401
 402 /*********************************************************************
 403  *              __toascii (MSVCRT.@)
 404  */
 405 int CDECL MSVCRT___toascii(int c)
 406 {
 407   return (unsigned)c & 0x7f;
 408 }
 409
 410 /*********************************************************************
 411  *              iswascii (MSVCRT.@)
 412  *
 413  */
 414 int CDECL MSVCRT_iswascii(MSVCRT_wchar_t c)
 415 {
 416   return ((unsigned)c < 0x80);
 417 }
 418
 419 /*********************************************************************
 420  *              __iscsym (MSVCRT.@)
 421  */
 422 int CDECL MSVCRT___iscsym(int c)
 423 {
 424   return (c < 127 && (MSVCRT_isalnum(c) || c == '_'));
 425 }
 426
 427 /*********************************************************************
 428  *              __iscsymf (MSVCRT.@)
 429  */
 430 int CDECL MSVCRT___iscsymf(int c)
 431 {
 432   return (c < 127 && (MSVCRT_isalpha(c) || c == '_'));
 433 }
 434
 435 /*********************************************************************
 436  *              _toupper_l (MSVCRT.@)
 437  */
 438 int CDECL MSVCRT__toupper_l(int c, MSVCRT__locale_t locale)
 439 {
 440     MSVCRT_pthreadlocinfo locinfo;
 441     unsigned char str[2], *p = str, ret[2];
 442
 443     if(!locale)
 444         locinfo = get_locinfo();
 445     else
 446         locinfo = locale->locinfo;
 447
 448     if((unsigned)c < 256)
 449         return locinfo->pcumap[c];
 450
 451     if(locinfo->pctype[(c>>8)&255] & MSVCRT__LEADBYTE)
 452         *p++ = (c>>8) & 255;
 453     else {
 454         *MSVCRT__errno() = MSVCRT_EILSEQ;
 455         str[1] = 0;
 456     }
 457     *p++ = c & 255;
 458
 459     switch(__crtLCMapStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], LCMAP_UPPERCASE,
 460                 (char*)str, p-str, (char*)ret, 2, locinfo->lc_codepage, 0))
 461     {
 462     case 0:
 463         return c;
 464     case 1:
 465         return ret[0];
 466     default:
 467         return ret[0] + (ret[1]<<8);
 468     }
 469 }
 470
 471 /*********************************************************************
 472  *              toupper (MSVCRT.@)
 473  */
 474 int CDECL MSVCRT_toupper(int c)
 475 {
 476     if(initial_locale)
 477         return c>='a' && c<='z' ? c-'a'+'A' : c;
 478     return MSVCRT__toupper_l(c, NULL);
 479 }
 480
 481 /*********************************************************************
 482  *              _toupper (MSVCRT.@)
 483  */
 484 int CDECL MSVCRT__toupper(int c)
 485 {
 486     return c - 0x20;  /* sic */
 487 }
 488
 489 /*********************************************************************
 490  *              _tolower_l (MSVCRT.@)
 491  */
 492 int CDECL MSVCRT__tolower_l(int c, MSVCRT__locale_t locale)
 493 {
 494     MSVCRT_pthreadlocinfo locinfo;
 495     unsigned char str[2], *p = str, ret[2];
 496
 497     if(!locale)
 498         locinfo = get_locinfo();
 499     else
 500         locinfo = locale->locinfo;
 501
 502     if((unsigned)c < 256)
 503         return locinfo->pclmap[c];
 504
 505     if(locinfo->pctype[(c>>8)&255] & MSVCRT__LEADBYTE)
 506         *p++ = (c>>8) & 255;
 507     else {
 508         *MSVCRT__errno() = MSVCRT_EILSEQ;
 509         str[1] = 0;
 510     }
 511     *p++ = c & 255;
 512
 513     switch(__crtLCMapStringA(locinfo->lc_handle[MSVCRT_LC_CTYPE], LCMAP_LOWERCASE,
 514                 (char*)str, p-str, (char*)ret, 2, locinfo->lc_codepage, 0))
 515     {
 516     case 0:
 517         return c;
 518     case 1:
 519         return ret[0];
 520     default:
 521         return ret[0] + (ret[1]<<8);
 522     }
 523 }
 524
 525 /*********************************************************************
 526  *              tolower (MSVCRT.@)
 527  */
 528 int CDECL MSVCRT_tolower(int c)
 529 {
 530     if(initial_locale)
 531         return c>='A' && c<='Z' ? c-'A'+'a' : c;
 532     return MSVCRT__tolower_l(c, NULL);
 533 }
 534
 535 /*********************************************************************
 536  *              _tolower (MSVCRT.@)
 537  */
 538 int CDECL MSVCRT__tolower(int c)
 539 {
 540     return c + 0x20;  /* sic */
 541 }
 542
 543 #if _MSVCR_VER>=120
 544 /*********************************************************************
 545  *              wctype (MSVCR120.@)
 546  */
 547 unsigned short __cdecl wctype(const char *property)
 548 {
 549     static const struct {
 550         const char *name;
 551         unsigned short mask;
 552     } properties[] = {
 553         { "alnum", MSVCRT__DIGIT|MSVCRT__ALPHA },
 554         { "alpha", MSVCRT__ALPHA },
 555         { "cntrl", MSVCRT__CONTROL },
 556         { "digit", MSVCRT__DIGIT },
 557         { "graph", MSVCRT__DIGIT|MSVCRT__PUNCT|MSVCRT__ALPHA },
 558         { "lower", MSVCRT__LOWER },
 559         { "print", MSVCRT__DIGIT|MSVCRT__PUNCT|MSVCRT__BLANK|MSVCRT__ALPHA },
 560         { "punct", MSVCRT__PUNCT },
 561         { "space", MSVCRT__SPACE },
 562         { "upper", MSVCRT__UPPER },
 563         { "xdigit", MSVCRT__HEX }
 564     };
 565     unsigned int i;
 566
 567     for(i=0; i<ARRAY_SIZE(properties); i++)
 568         if(!strcmp(property, properties[i].name))
 569             return properties[i].mask;
 570
 571     return 0;
 572 }
 573 #endif