root/ext/intl/uchar/uchar.c

DEFINITIONS

1. convert_cp
2. ZEND_BEGIN_ARG_INFO_EX
3. ZEND_BEGIN_ARG_INFO_EX
4. ZEND_BEGIN_ARG_INFO_EX
5. ZEND_BEGIN_ARG_INFO_EX
6. ZEND_BEGIN_ARG_INFO_EX
7. ZEND_BEGIN_ARG_INFO_EX
8. ZEND_BEGIN_ARG_INFO_EX
9. ZEND_BEGIN_ARG_INFO_EX
10. enumCharType_callback
11. IC_METHOD
12. ZEND_BEGIN_ARG_INFO_EX
13. ZEND_BEGIN_ARG_INFO_EX
14. ZEND_BEGIN_ARG_INFO_EX
15. ZEND_BEGIN_ARG_INFO_EX
16. enumCharNames_callback
17. IC_METHOD
18. ZEND_BEGIN_ARG_INFO_EX
19. ZEND_BEGIN_ARG_INFO_EX
20. ZEND_BEGIN_ARG_INFO_EX
21. ZEND_BEGIN_ARG_INFO_EX
22. ZEND_BEGIN_ARG_INFO_EX
23. ZEND_BEGIN_ARG_INFO_EX
24. ZEND_BEGIN_ARG_INFO_EX
25. ZEND_BEGIN_ARG_INFO_EX
26. ZEND_BEGIN_ARG_INFO_EX
27. ZEND_BEGIN_ARG_INFO_EX
28. php_uchar_minit

   1 #include "uchar.h"
   2 #include "intl_data.h"
   3 #include "intl_convert.h"
   4 
   5 #include <unicode/uchar.h>
   6 
   7 #define IC_METHOD(mname) PHP_METHOD(IntlChar, mname)
   8 
   9 static inline int convert_cp(UChar32* pcp, zval *zcp) {
  10         zend_long cp = -1;
  11         if (Z_TYPE_P(zcp) == IS_LONG) {
  12                 cp = Z_LVAL_P(zcp);
  13         } else if (Z_TYPE_P(zcp) == IS_STRING) {
  14                 int i = 0;
  15                 U8_NEXT(Z_STRVAL_P(zcp), i, Z_STRLEN_P(zcp), cp);
  16                 if (i != Z_STRLEN_P(zcp)) {
  17                         intl_error_set_code(NULL, U_ILLEGAL_ARGUMENT_ERROR);
  18                         intl_error_set_custom_msg(NULL, "Passing a UTF-8 character for codepoint requires a string which is exactly one UTF-8 codepoint long.", 0);
  19                         return FAILURE;
  20                 }
  21         } else {
  22                 intl_error_set_code(NULL, U_ILLEGAL_ARGUMENT_ERROR);
  23                 intl_error_set_custom_msg(NULL, "Invalid parameter for unicode point.  Must be either integer or UTF-8 sequence.", 0);
  24                 return FAILURE;
  25         }
  26         if ((cp < UCHAR_MIN_VALUE) || (cp > UCHAR_MAX_VALUE)) {
  27                 intl_error_set_code(NULL, U_ILLEGAL_ARGUMENT_ERROR);
  28                 intl_error_set_custom_msg(NULL, "Codepoint out of range", 0);
  29                 return FAILURE;
  30         }
  31         *pcp = (UChar32)cp;
  32         return SUCCESS;
  33 }
  34 
  35 /* {{{ proto string IntlChar::chr(int|string $codepoint)
  36  * Converts a numeric codepoint to UTF-8
  37  * Acts as an identify function when given a valid UTF-8 encoded codepoint
  38  */
  39 ZEND_BEGIN_ARG_INFO_EX(chr_arginfo, 0, ZEND_RETURN_VALUE, 1)
  40         ZEND_ARG_INFO(0, codepoint)
  41 ZEND_END_ARG_INFO();
  42 IC_METHOD(chr) {
  43         UChar32 cp;
  44         zval *zcp;
  45         char buffer[5];
  46         int buffer_len = 0;
  47 
  48         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) ||
  49             (convert_cp(&cp, zcp) == FAILURE)) {
  50                 return;
  51         }
  52 
  53         /* We can use unsafe because we know the codepoint is in valid range
  54          * and that 4 bytes is enough for any unicode point
  55          */
  56         U8_APPEND_UNSAFE(buffer, buffer_len, cp);
  57         buffer[buffer_len] = 0;
  58         RETURN_STRINGL(buffer, buffer_len);
  59 }
  60 /* }}} */
  61 
  62 /* {{{ proto int IntlChar::ord(int|string $character)
  63  * Converts a UTf-8 encoded codepoint to its integer U32 value
  64  * Acts as an identity function when passed a valid integer codepoint
  65  */
  66 ZEND_BEGIN_ARG_INFO_EX(ord_arginfo, 0, ZEND_RETURN_VALUE, 1)
  67         ZEND_ARG_INFO(0, character)
  68 ZEND_END_ARG_INFO();
  69 IC_METHOD(ord) {
  70         UChar32 cp;
  71         zval *zcp;
  72 
  73         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) ||
  74             (convert_cp(&cp, zcp) == FAILURE)) {
  75                 return;
  76         }
  77 
  78         RETURN_LONG(cp);
  79 }
  80 /* }}} */
  81 
  82 /* {{{ proto bool IntlChar::hasBinaryProperty(int|string $codepoint, int $property) */
  83 ZEND_BEGIN_ARG_INFO_EX(hasBinaryProperty_arginfo, 0, ZEND_RETURN_VALUE, 2)
  84         ZEND_ARG_INFO(0, codepoint)
  85         ZEND_ARG_INFO(0, property)
  86 ZEND_END_ARG_INFO();
  87 IC_METHOD(hasBinaryProperty) {
  88         UChar32 cp;
  89         zend_long prop;
  90         zval *zcp;
  91 
  92         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "zl", &zcp, &prop) == FAILURE) ||
  93             (convert_cp(&cp, zcp) == FAILURE)) {
  94                 return;
  95         }
  96 
  97         RETURN_BOOL(u_hasBinaryProperty(cp, (UProperty)prop));
  98 }
  99 /* }}} */
 100 
 101 /* {{{ proto int IntlChar::getIntPropertyValue(int|string $codepoint, int $property) */
 102 ZEND_BEGIN_ARG_INFO_EX(getIntPropertyValue_arginfo, 0, ZEND_RETURN_VALUE, 2)
 103         ZEND_ARG_INFO(0, codepoint)
 104         ZEND_ARG_INFO(0, property)
 105 ZEND_END_ARG_INFO();
 106 IC_METHOD(getIntPropertyValue) {
 107         UChar32 cp;
 108         zend_long prop;
 109         zval *zcp;
 110 
 111         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "zl", &zcp, &prop) == FAILURE) ||
 112             (convert_cp(&cp, zcp) == FAILURE)) {
 113                 return;
 114         }
 115 
 116         RETURN_LONG(u_getIntPropertyValue(cp, (UProperty)prop));
 117 }
 118 /* }}} */
 119 
 120 /* {{{ proto int IntlChar::getIntPropertyMinValue(int $property) */
 121 ZEND_BEGIN_ARG_INFO_EX(getIntPropertyMinValue_arginfo, 0, ZEND_RETURN_VALUE, 1)
 122         ZEND_ARG_INFO(0, property)
 123 ZEND_END_ARG_INFO();
 124 IC_METHOD(getIntPropertyMinValue) {
 125         zend_long prop;
 126 
 127         if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &prop) == FAILURE) {
 128                 return;
 129         }
 130 
 131         RETURN_LONG(u_getIntPropertyMinValue((UProperty)prop));
 132 }
 133 /* }}} */
 134 
 135 /* {{{ proto int IntlChar::getIntPropertyMxValue(int $property) */
 136 ZEND_BEGIN_ARG_INFO_EX(getIntPropertyMaxValue_arginfo, 0, ZEND_RETURN_VALUE, 1)
 137         ZEND_ARG_INFO(0, property)
 138 ZEND_END_ARG_INFO();
 139 IC_METHOD(getIntPropertyMaxValue) {
 140         zend_long prop;
 141 
 142         if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &prop) == FAILURE) {
 143                 return;
 144         }
 145 
 146         RETURN_LONG(u_getIntPropertyMaxValue((UProperty)prop));
 147 }
 148 /* }}} */
 149 
 150 /* {{{ proto float IntlChar::getNumericValue(int|string $codepoint) */
 151 ZEND_BEGIN_ARG_INFO_EX(getNumericValue_arginfo, 0, ZEND_RETURN_VALUE, 1)
 152         ZEND_ARG_INFO(0, codepoint)
 153 ZEND_END_ARG_INFO();
 154 IC_METHOD(getNumericValue) {
 155         UChar32 cp;
 156         zval *zcp;
 157 
 158         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) ||
 159             (convert_cp(&cp, zcp) == FAILURE)) {
 160                 return;
 161         }
 162 
 163         RETURN_DOUBLE(u_getNumericValue(cp));
 164 }
 165 /* }}} */
 166 
 167 /* {{{ proto void IntlChar::enumCharTypes(callable $callback) */
 168 ZEND_BEGIN_ARG_INFO_EX(enumCharTypes_arginfo, 0, ZEND_RETURN_VALUE, 0)
 169         ZEND_ARG_INFO(0, callback)
 170 ZEND_END_ARG_INFO();
 171 typedef struct _enumCharType_data {
 172         zend_fcall_info fci;
 173         zend_fcall_info_cache fci_cache;
 174 } enumCharType_data;
 175 static UBool enumCharType_callback(enumCharType_data *context,
 176                                    UChar32 start, UChar32 limit,
 177                                    UCharCategory type) {
 178         zval retval;
 179         zval args[3];
 180 
 181         ZVAL_NULL(&retval);
 182         /* Note that $start is INclusive, whiel $limit is EXclusive
 183          * Therefore (0, 32, 15) means CPs 0..31 are of type 15
 184          */
 185         ZVAL_LONG(&args[0], start);
 186         ZVAL_LONG(&args[1], limit);
 187         ZVAL_LONG(&args[2], type);
 188 
 189         context->fci.retval = &retval;
 190         context->fci.param_count = 3;
 191         context->fci.params = args;
 192 
 193         if (zend_call_function(&context->fci, &context->fci_cache) == FAILURE) {
 194                 intl_error_set_code(NULL, U_INTERNAL_PROGRAM_ERROR);
 195                 intl_errors_set_custom_msg(NULL, "enumCharTypes callback failed", 0);
 196                 zval_dtor(&retval);
 197                 return 0;
 198         }
 199         zval_dtor(&retval);
 200         return 1;
 201 }
 202 IC_METHOD(enumCharTypes) {
 203         enumCharType_data context;
 204 
 205         if (zend_parse_parameters(ZEND_NUM_ARGS(), "f", &context.fci, &context.fci_cache) == FAILURE) {
 206                 return;
 207         }
 208         u_enumCharTypes((UCharEnumTypeRange*)enumCharType_callback, &context);
 209 }
 210 /* }}} */
 211 
 212 /* {{{ proto int IntlChar::getBlockCode(int|string $codepoint) */
 213 ZEND_BEGIN_ARG_INFO_EX(getBlockCode_arginfo, 0, ZEND_RETURN_VALUE, 1)
 214         ZEND_ARG_INFO(0, codepoint)
 215 ZEND_END_ARG_INFO()
 216 IC_METHOD(getBlockCode) {
 217         UChar32 cp;
 218         zval *zcp;
 219 
 220         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) ||
 221             (convert_cp(&cp, zcp) == FAILURE)) {
 222                 return;
 223         }
 224 
 225         RETURN_LONG(ublock_getCode(cp));
 226 }
 227 /* }}} */
 228 
 229 /* {{{ proto string IntlChar::charName(int|string $codepoint, int $nameChoice = IntlChar::UNICODE_CHAR_NAME) */
 230 ZEND_BEGIN_ARG_INFO_EX(charName_arginfo, 0, ZEND_RETURN_VALUE, 1)
 231         ZEND_ARG_INFO(0, codepoint)
 232         ZEND_ARG_INFO(0, nameChoice)
 233 ZEND_END_ARG_INFO()
 234 IC_METHOD(charName) {
 235         UChar32 cp;
 236         zval *zcp;
 237         UErrorCode error = U_ZERO_ERROR;
 238         zend_long nameChoice = U_UNICODE_CHAR_NAME;
 239         zend_string *buffer = NULL;
 240         int32_t buffer_len;
 241 
 242         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z|l", &zcp, &nameChoice) == FAILURE) ||
 243             (convert_cp(&cp, zcp) == FAILURE)) {
 244                 return;
 245         }
 246 
 247         buffer_len = u_charName(cp, (UCharNameChoice)nameChoice, NULL, 0, &error);
 248         buffer = zend_string_alloc(buffer_len, 0);
 249         error = U_ZERO_ERROR;
 250         buffer_len = u_charName(cp, (UCharNameChoice)nameChoice, ZSTR_VAL(buffer), ZSTR_LEN(buffer) + 1, &error);
 251         if (U_FAILURE(error)) {
 252                 zend_string_free(buffer);
 253                 INTL_CHECK_STATUS(error, "Failure getting character name");
 254         }
 255         RETURN_NEW_STR(buffer);
 256 }
 257 /* }}} */
 258 
 259 /* {{{ proto int IntlChar::charFromName(string $characterName, int $nameChoice = IntlChar::UNICODE_CHAR_NAME) */
 260 ZEND_BEGIN_ARG_INFO_EX(charFromName_arginfo, 0, ZEND_RETURN_VALUE, 1)
 261         ZEND_ARG_INFO(0, characterName)
 262         ZEND_ARG_INFO(0, nameChoice)
 263 ZEND_END_ARG_INFO()
 264 IC_METHOD(charFromName) {
 265         char *name;
 266         size_t name_len;
 267         zend_long nameChoice = U_UNICODE_CHAR_NAME;
 268         UChar32 ret;
 269         UErrorCode error = U_ZERO_ERROR;
 270 
 271         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s|l", &name, &name_len, &nameChoice) == FAILURE) {
 272                 return;
 273         }
 274 
 275         ret = u_charFromName((UCharNameChoice)nameChoice, name, &error);
 276         INTL_CHECK_STATUS(error, NULL);
 277         RETURN_LONG(ret);
 278 }
 279 /* }}} */
 280 
 281 /* {{{ void void IntlChar::enumCharNames(int|string $start, int|string $limit, callable $callback, int $nameChoice = IntlChar::UNICODE_CHAR_NAME) */
 282 ZEND_BEGIN_ARG_INFO_EX(enumCharNames_arginfo, 0, ZEND_RETURN_VALUE, 3)
 283         ZEND_ARG_INFO(0, start)
 284         ZEND_ARG_INFO(0, limit)
 285         ZEND_ARG_INFO(0, callback)
 286         ZEND_ARG_INFO(0, nameChoice)
 287 ZEND_END_ARG_INFO();
 288 typedef struct _enumCharNames_data {
 289         zend_fcall_info fci;
 290         zend_fcall_info_cache fci_cache;
 291 } enumCharNames_data;
 292 static UBool enumCharNames_callback(enumCharNames_data *context,
 293                                     UChar32 code, UCharNameChoice nameChoice,
 294                                     const char *name, int32_t length) {
 295         zval retval;
 296         zval args[3];
 297 
 298         ZVAL_NULL(&retval);
 299         ZVAL_LONG(&args[0], code);
 300         ZVAL_LONG(&args[1], nameChoice);
 301         ZVAL_STRINGL(&args[2], name, length);
 302 
 303         context->fci.retval = &retval;
 304         context->fci.param_count = 3;
 305         context->fci.params = args;
 306 
 307         if (zend_call_function(&context->fci, &context->fci_cache) == FAILURE) {
 308                 intl_error_set_code(NULL, U_INTERNAL_PROGRAM_ERROR);
 309                 intl_error_set_custom_msg(NULL, "enumCharNames callback failed", 0);
 310                 zval_dtor(&retval);
 311                 zval_dtor(&args[2]);
 312                 return 0;
 313         }
 314         zval_dtor(&retval);
 315         zval_dtor(&args[2]);
 316         return 1;
 317 }
 318 IC_METHOD(enumCharNames) {
 319         UChar32 start, limit;
 320         zval *zstart, *zlimit;
 321         enumCharNames_data context;
 322         zend_long nameChoice = U_UNICODE_CHAR_NAME;
 323         UErrorCode error = U_ZERO_ERROR;
 324 
 325         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "zzf|l", &zstart, &zlimit, &context.fci, &context.fci_cache, &nameChoice) == FAILURE) ||
 326             (convert_cp(&start, zstart) == FAILURE) ||
 327             (convert_cp(&limit, zlimit) == FAILURE)) {
 328                 return;
 329         }
 330 
 331         u_enumCharNames(start, limit, (UEnumCharNamesFn*)enumCharNames_callback, &context, nameChoice, &error);
 332         INTL_CHECK_STATUS(error, NULL);
 333 }
 334 /* }}} */
 335 
 336 /* {{{ proto string IntlChar::getPropertyName(int $property, int $nameChoice = IntlChar::LONG_PROPERTY_NAME) */
 337 ZEND_BEGIN_ARG_INFO_EX(getPropertyName_arginfo, 0, ZEND_RETURN_VALUE, 1)
 338         ZEND_ARG_INFO(0, property)
 339         ZEND_ARG_INFO(0, nameChoice)
 340 ZEND_END_ARG_INFO();
 341 IC_METHOD(getPropertyName) {
 342         zend_long property;
 343         zend_long nameChoice = U_LONG_PROPERTY_NAME;
 344         const char *ret;
 345 
 346         if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|l", &property, &nameChoice) == FAILURE) {
 347                 return;
 348         }
 349 
 350         ret = u_getPropertyName((UProperty)property, (UPropertyNameChoice)nameChoice);
 351         if (ret) {
 352                 RETURN_STRING(ret);
 353         } else {
 354                 intl_error_set_code(NULL, U_ILLEGAL_ARGUMENT_ERROR);
 355                 intl_error_set_custom_msg(NULL, "Failed to get property name", 0);
 356                 RETURN_FALSE;
 357         }
 358 }
 359 /* }}} */
 360 
 361 /* {{{ proto int IntlChar::getPropertyEnum(string $alias) */
 362 ZEND_BEGIN_ARG_INFO_EX(getPropertyEnum_arginfo, 0, ZEND_RETURN_VALUE, 1)
 363         ZEND_ARG_INFO(0, alias)
 364 ZEND_END_ARG_INFO();
 365 IC_METHOD(getPropertyEnum) {
 366         char *alias;
 367         size_t alias_len;
 368 
 369         if (zend_parse_parameters(ZEND_NUM_ARGS(), "s", &alias, &alias_len) == FAILURE) {
 370                 return;
 371         }
 372 
 373         RETURN_LONG(u_getPropertyEnum(alias));
 374 }
 375 /* }}} */
 376 
 377 /* {{{ proto string IntlChar::getPropertyValueName(int $property, int $value[, int $nameChoice = IntlChar::LONG_PROPERTY_NAME) */
 378 ZEND_BEGIN_ARG_INFO_EX(getPropertyValueName_arginfo, 0, ZEND_RETURN_VALUE, 2)
 379         ZEND_ARG_INFO(0, property)
 380         ZEND_ARG_INFO(0, value)
 381         ZEND_ARG_INFO(0, nameChoice)
 382 ZEND_END_ARG_INFO();
 383 IC_METHOD(getPropertyValueName) {
 384         zend_long property, value, nameChoice = U_LONG_PROPERTY_NAME;
 385         const char *ret;
 386 
 387         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ll|l", &property, &value, &nameChoice) == FAILURE) {
 388                 return;
 389         }
 390 
 391         ret = u_getPropertyValueName((UProperty)property, value, (UPropertyNameChoice)nameChoice);
 392         if (ret) {
 393                 RETURN_STRING(ret);
 394         } else {
 395                 intl_error_set_code(NULL, U_ILLEGAL_ARGUMENT_ERROR);
 396                 intl_error_set_custom_msg(NULL, "Failed to get property name", 0);
 397                 RETURN_FALSE;
 398         }
 399 }
 400 /* }}} */
 401 
 402 /* {{{ proto int IntlChar::getPropertyValueEnum(int $property, string $name) */
 403 ZEND_BEGIN_ARG_INFO_EX(getPropertyValueEnum_arginfo, 0, ZEND_RETURN_VALUE, 2)
 404         ZEND_ARG_INFO(0, property)
 405         ZEND_ARG_INFO(0, name)
 406 ZEND_END_ARG_INFO();
 407 IC_METHOD(getPropertyValueEnum) {
 408         zend_long property;
 409         char *name;
 410         size_t name_len;
 411 
 412         if (zend_parse_parameters(ZEND_NUM_ARGS(), "ls", &property, &name, &name_len) == FAILURE) {
 413                 return;
 414         }
 415 
 416         RETURN_LONG(u_getPropertyValueEnum((UProperty)property, name));
 417 }
 418 /* }}} */
 419 
 420 /* {{{ proto int|string IntlChar::foldCase(int|string $codepoint, int $options = IntlChar::FOLD_CASE_DEFAULT) */
 421 ZEND_BEGIN_ARG_INFO_EX(foldCase_arginfo, 0, ZEND_RETURN_VALUE, 1)
 422         ZEND_ARG_INFO(0, codepoint)
 423         ZEND_ARG_INFO(0, options)
 424 ZEND_END_ARG_INFO();
 425 IC_METHOD(foldCase) {
 426         UChar32 cp, ret;
 427         zval *zcp;
 428         zend_long options = U_FOLD_CASE_DEFAULT;
 429 
 430         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z|l", &zcp, &options) == FAILURE) ||
 431             (convert_cp(&cp, zcp) == FAILURE)) {
 432                 return;
 433         }
 434 
 435         ret = u_foldCase(cp, options);
 436         if (Z_TYPE_P(zcp) == IS_STRING) {
 437                 char buffer[5];
 438                 int buffer_len = 0;
 439                 U8_APPEND_UNSAFE(buffer, buffer_len, ret);
 440                 buffer[buffer_len] = 0;
 441                 RETURN_STRINGL(buffer, buffer_len);
 442         } else {
 443                 RETURN_LONG(ret);
 444         }
 445 }
 446 /* }}} */
 447 
 448 /* {{{ proto int IntlChar::digit(int|string $codepoint[, int $radix = 10]) */
 449 ZEND_BEGIN_ARG_INFO_EX(digit_arginfo, 0, ZEND_RETURN_VALUE, 1)
 450         ZEND_ARG_INFO(0, codepoint)
 451         ZEND_ARG_INFO(0, radix)
 452 ZEND_END_ARG_INFO();
 453 IC_METHOD(digit) {
 454         UChar32 cp;
 455         zval *zcp;
 456         zend_long radix = 10;
 457         int ret;
 458 
 459         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z|l", &zcp, &radix) == FAILURE) ||
 460             (convert_cp(&cp, zcp) == FAILURE)) {
 461                 return;
 462         }
 463 
 464         ret = u_digit(cp, radix);
 465         if (ret < 0) {
 466                 intl_error_set_code(NULL, U_ILLEGAL_ARGUMENT_ERROR);
 467                 intl_error_set_custom_msg(NULL, "Invalid digit", 0);
 468                 RETURN_FALSE;
 469         }
 470         RETURN_LONG(ret);
 471 }
 472 /* }}} */
 473 
 474 /* {{{ proto int IntlChar::forDigit(int $digit[, int $radix = 10]) */
 475 ZEND_BEGIN_ARG_INFO_EX(forDigit_arginfo, 0, ZEND_RETURN_VALUE, 1)
 476         ZEND_ARG_INFO(0, digit)
 477         ZEND_ARG_INFO(0, radix)
 478 ZEND_END_ARG_INFO();
 479 IC_METHOD(forDigit) {
 480         zend_long digit, radix = 10;
 481 
 482         if (zend_parse_parameters(ZEND_NUM_ARGS(), "l|l", &digit, &radix) == FAILURE) {
 483                 return;
 484         }
 485 
 486         RETURN_LONG(u_forDigit(digit, radix));
 487 }
 488 /* }}} */
 489 
 490 /* {{{ proto array IntlChar::charAge(int|string $codepoint) */
 491 ZEND_BEGIN_ARG_INFO_EX(charAge_arginfo, 0, ZEND_RETURN_VALUE, 1)
 492         ZEND_ARG_INFO(0, codepoint)
 493 ZEND_END_ARG_INFO();
 494 IC_METHOD(charAge) {
 495         UChar32 cp;
 496         zval *zcp;
 497         UVersionInfo version;
 498         int i;
 499 
 500         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) ||
 501             (convert_cp(&cp, zcp) == FAILURE)) {
 502                 return;
 503         }
 504 
 505         u_charAge(cp, version);
 506         array_init(return_value);
 507         for(i = 0; i < U_MAX_VERSION_LENGTH; ++i) {
 508                 add_next_index_long(return_value, version[i]);
 509         }
 510 }
 511 /* }}} */
 512 
 513 /* {{{ proto array IntlChar::getUnicodeVersion() */
 514 ZEND_BEGIN_ARG_INFO_EX(getUnicodeVersion_arginfo, 0, ZEND_RETURN_VALUE, 0)
 515 ZEND_END_ARG_INFO();
 516 IC_METHOD(getUnicodeVersion) {
 517         UVersionInfo version;
 518         int i;
 519 
 520 
 521         u_getUnicodeVersion(version);
 522         array_init(return_value);
 523         for(i = 0; i < U_MAX_VERSION_LENGTH; ++i) {
 524                 add_next_index_long(return_value, version[i]);
 525         }
 526 }
 527 /* }}} */
 528 
 529 /* {{{ proto string IntlChar::getFC_NFKC_Closure(int|string $codepoint) */
 530 ZEND_BEGIN_ARG_INFO_EX(getFC_NFKC_Closure_arginfo, 0, ZEND_RETURN_VALUE, 1)
 531         ZEND_ARG_INFO(0, codepoint)
 532 ZEND_END_ARG_INFO();
 533 IC_METHOD(getFC_NFKC_Closure) {
 534         UChar32 cp;
 535         zval *zcp;
 536         UChar *closure;
 537         zend_string *u8str;
 538         int32_t closure_len;
 539         UErrorCode error = U_ZERO_ERROR;
 540 
 541         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) ||
 542             (convert_cp(&cp, zcp) == FAILURE)) {
 543                 return;
 544         }
 545 
 546         closure_len = u_getFC_NFKC_Closure(cp, NULL, 0, &error);
 547         if (closure_len == 0) {
 548                 RETURN_EMPTY_STRING();
 549         }
 550         closure = safe_emalloc(sizeof(UChar), closure_len + 1, 0);
 551         error = U_ZERO_ERROR;
 552         closure_len = u_getFC_NFKC_Closure(cp, closure, closure_len, &error);
 553         if (U_FAILURE(error)) {
 554                 efree(closure);
 555                 INTL_CHECK_STATUS(error, "Failed getting closure");
 556         }
 557 
 558         error = U_ZERO_ERROR;
 559         u8str = intl_convert_utf16_to_utf8(closure, closure_len, &error);
 560         efree(closure);
 561         INTL_CHECK_STATUS(error, "Failed converting output to UTF8");
 562         RETVAL_NEW_STR(u8str);
 563 }
 564 /* }}} */
 565 
 566 /* {{{ proto bool IntlChar::<name>(int|string $codepoint) */
 567 #define IC_BOOL_METHOD_CHAR(name) \
 568 ZEND_BEGIN_ARG_INFO_EX(name##_arginfo, 0, ZEND_RETURN_VALUE, 1) \
 569         ZEND_ARG_INFO(0, codepoint) \
 570 ZEND_END_ARG_INFO(); \
 571 IC_METHOD(name) { \
 572         UChar32 cp; zval *zcp; \
 573         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) || \
 574             (convert_cp(&cp, zcp) == FAILURE)) { return; } \
 575         RETURN_BOOL(u_##name(cp)); \
 576 }
 577 IC_BOOL_METHOD_CHAR(isUAlphabetic)
 578 IC_BOOL_METHOD_CHAR(isULowercase)
 579 IC_BOOL_METHOD_CHAR(isUUppercase)
 580 IC_BOOL_METHOD_CHAR(isUWhiteSpace)
 581 IC_BOOL_METHOD_CHAR(islower)
 582 IC_BOOL_METHOD_CHAR(isupper)
 583 IC_BOOL_METHOD_CHAR(istitle)
 584 IC_BOOL_METHOD_CHAR(isdigit)
 585 IC_BOOL_METHOD_CHAR(isalpha)
 586 IC_BOOL_METHOD_CHAR(isalnum)
 587 IC_BOOL_METHOD_CHAR(isxdigit)
 588 IC_BOOL_METHOD_CHAR(ispunct)
 589 IC_BOOL_METHOD_CHAR(isgraph)
 590 IC_BOOL_METHOD_CHAR(isblank)
 591 IC_BOOL_METHOD_CHAR(isdefined)
 592 IC_BOOL_METHOD_CHAR(isspace)
 593 IC_BOOL_METHOD_CHAR(isJavaSpaceChar)
 594 IC_BOOL_METHOD_CHAR(isWhitespace)
 595 IC_BOOL_METHOD_CHAR(iscntrl)
 596 IC_BOOL_METHOD_CHAR(isISOControl)
 597 IC_BOOL_METHOD_CHAR(isprint)
 598 IC_BOOL_METHOD_CHAR(isbase)
 599 IC_BOOL_METHOD_CHAR(isMirrored)
 600 IC_BOOL_METHOD_CHAR(isIDStart)
 601 IC_BOOL_METHOD_CHAR(isIDPart)
 602 IC_BOOL_METHOD_CHAR(isIDIgnorable)
 603 IC_BOOL_METHOD_CHAR(isJavaIDStart)
 604 IC_BOOL_METHOD_CHAR(isJavaIDPart)
 605 #undef IC_BOOL_METHOD_CHAR
 606 /* }}} */
 607 
 608 /* {{{ proto int IntlChar::<name>(int|string $codepoint) */
 609 #define IC_INT_METHOD_CHAR(name) \
 610 ZEND_BEGIN_ARG_INFO_EX(name##_arginfo, 0, ZEND_RETURN_VALUE, 1) \
 611         ZEND_ARG_INFO(0, codepoint) \
 612 ZEND_END_ARG_INFO(); \
 613 IC_METHOD(name) { \
 614         UChar32 cp; zval *zcp; \
 615         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) || \
 616             (convert_cp(&cp, zcp) == FAILURE)) { return; } \
 617         RETURN_LONG(u_##name(cp)); \
 618 }
 619 IC_INT_METHOD_CHAR(charDirection)
 620 IC_INT_METHOD_CHAR(charType)
 621 IC_INT_METHOD_CHAR(getCombiningClass)
 622 IC_INT_METHOD_CHAR(charDigitValue)
 623 #undef IC_INT_METHOD_CHAR
 624 /* }}} */
 625 
 626 /* {{{ proto int|string IntlChar::<name>(int|string $codepoint)
 627  * Returns a utf-8 character if codepoint was passed as a utf-8 sequence
 628  * Returns an int otherwise
 629  */
 630 #define IC_CHAR_METHOD_CHAR(name) \
 631 ZEND_BEGIN_ARG_INFO_EX(name##_arginfo, 0, ZEND_RETURN_VALUE, 1) \
 632         ZEND_ARG_INFO(0, codepoint) \
 633 ZEND_END_ARG_INFO(); \
 634 IC_METHOD(name) { \
 635         UChar32 cp, ret; zval *zcp; \
 636         if ((zend_parse_parameters(ZEND_NUM_ARGS(), "z", &zcp) == FAILURE) || \
 637             (convert_cp(&cp, zcp) == FAILURE)) { return; } \
 638         ret = u_##name(cp); \
 639         if (Z_TYPE_P(zcp) == IS_STRING) { \
 640                 char buffer[5]; \
 641                 int buffer_len = 0; \
 642                 U8_APPEND_UNSAFE(buffer, buffer_len, ret); \
 643                 buffer[buffer_len] = 0; \
 644                 RETURN_STRINGL(buffer, buffer_len); \
 645         } else { \
 646                 RETURN_LONG(ret); \
 647         } \
 648 }
 649 IC_CHAR_METHOD_CHAR(charMirror)
 650 IC_CHAR_METHOD_CHAR(tolower)
 651 IC_CHAR_METHOD_CHAR(toupper)
 652 IC_CHAR_METHOD_CHAR(totitle)
 653 #if U_ICU_VERSION_MAJOR_NUM >= 52
 654 IC_CHAR_METHOD_CHAR(getBidiPairedBracket)
 655 #endif /* ICU >= 52 */
 656 #undef IC_CHAR_METHOD_CHAR
 657 /* }}} */
 658 
 659 static zend_function_entry intlchar_methods[] = {
 660 #define IC_ME(mname) PHP_ME(IntlChar, mname, mname##_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
 661         IC_ME(chr)
 662         IC_ME(ord)
 663         IC_ME(hasBinaryProperty)
 664         IC_ME(isUAlphabetic)
 665         IC_ME(isULowercase)
 666         IC_ME(isUUppercase)
 667         IC_ME(isUWhiteSpace)
 668         IC_ME(getIntPropertyValue)
 669         IC_ME(getIntPropertyMinValue)
 670         IC_ME(getIntPropertyMaxValue)
 671         IC_ME(getNumericValue)
 672         IC_ME(islower)
 673         IC_ME(isupper)
 674         IC_ME(istitle)
 675         IC_ME(isdigit)
 676         IC_ME(isalpha)
 677         IC_ME(isalnum)
 678         IC_ME(isxdigit)
 679         IC_ME(ispunct)
 680         IC_ME(isgraph)
 681         IC_ME(isblank)
 682         IC_ME(isdefined)
 683         IC_ME(isspace)
 684         IC_ME(isJavaSpaceChar)
 685         IC_ME(isWhitespace)
 686         IC_ME(iscntrl)
 687         IC_ME(isISOControl)
 688         IC_ME(isprint)
 689         IC_ME(isbase)
 690         IC_ME(charDirection)
 691         IC_ME(isMirrored)
 692         IC_ME(charMirror)
 693 #if U_ICU_VERSION_MAJOR_NUM >= 52
 694         IC_ME(getBidiPairedBracket)
 695 #endif /* ICU >= 52 */
 696         IC_ME(charType)
 697         IC_ME(enumCharTypes)
 698         IC_ME(getCombiningClass)
 699         IC_ME(charDigitValue)
 700         IC_ME(getBlockCode)
 701         IC_ME(charName)
 702         IC_ME(charFromName)
 703         IC_ME(enumCharNames)
 704         IC_ME(getPropertyName)
 705         IC_ME(getPropertyEnum)
 706         IC_ME(getPropertyValueName)
 707         IC_ME(getPropertyValueEnum)
 708         IC_ME(isIDStart)
 709         IC_ME(isIDPart)
 710         IC_ME(isIDIgnorable)
 711         IC_ME(isJavaIDStart)
 712         IC_ME(isJavaIDPart)
 713         IC_ME(tolower)
 714         IC_ME(toupper)
 715         IC_ME(totitle)
 716         IC_ME(foldCase)
 717         IC_ME(digit)
 718         IC_ME(forDigit)
 719         IC_ME(charAge)
 720         IC_ME(getUnicodeVersion)
 721         IC_ME(getFC_NFKC_Closure)
 722 #undef IC_ME
 723         PHP_FE_END
 724 };
 725 
 726 int php_uchar_minit(INIT_FUNC_ARGS) {
 727         zend_class_entry tmp, *ce;
 728 
 729         INIT_CLASS_ENTRY(tmp, "IntlChar", intlchar_methods);
 730         ce = zend_register_internal_class(&tmp);
 731 
 732 #define IC_CONSTL(name, val) \
 733         zend_declare_class_constant_long(ce, name, strlen(name), val);
 734 
 735         zend_declare_class_constant_string(ce, "UNICODE_VERSION", sizeof("UNICODE_VERISON")-1, U_UNICODE_VERSION);
 736         IC_CONSTL("CODEPOINT_MIN", UCHAR_MIN_VALUE)
 737         IC_CONSTL("CODEPOINT_MAX", UCHAR_MAX_VALUE)
 738         IC_CONSTL("FOLD_CASE_DEFAULT", U_FOLD_CASE_DEFAULT)
 739         IC_CONSTL("FOLD_CASE_EXCLUDE_SPECIAL_I", U_FOLD_CASE_EXCLUDE_SPECIAL_I)
 740 
 741         /* All enums used by the uchar APIs.  There are a LOT of them,
 742          * so they're separated out into include files,
 743          * leaving this source file for actual implementation.
 744          */
 745 #define UPROPERTY(name) IC_CONSTL("PROPERTY_" #name, UCHAR_##name)
 746 #include "uproperty-enum.h"
 747 #undef UPROPERTY
 748 
 749 #define UCHARCATEGORY(name) IC_CONSTL("CHAR_CATEGORY_" #name, U_##name)
 750 #include "ucharcategory-enum.h"
 751 #undef UCHARCATEGORY
 752 
 753 #define UCHARDIRECTION(name) IC_CONSTL("CHAR_DIRECTION_" #name, U_##name)
 754 #include "uchardirection-enum.h"
 755 #undef UCHARDIRECTION
 756 
 757 #define UBLOCKCODE(name) IC_CONSTL("BLOCK_CODE_" #name, UBLOCK_##name)
 758 #include "ublockcode-enum.h"
 759 #undef UBLOCKCODE
 760 
 761         /* Smaller, self-destribing enums */
 762 #define UOTHER(name) IC_CONSTL(#name, U_##name)
 763 #include "uother-enum.h"
 764 #undef UOTHER
 765 
 766 #undef IC_CONSTL
 767 #undef IC_CONSTS
 768 
 769         return SUCCESS;
 770 }
 771