From 1b2b0f9a381b819746e662f072ca9694796f2039 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?M=C3=A1t=C3=A9=20Kocsis?= Date: Tue, 2 Aug 2022 17:27:16 +0200 Subject: [PATCH] Declare ext/intl constants in stubs - part 3 --- ext/intl/config.m4 | 1 - ext/intl/config.w32 | 1 - ext/intl/formatter/formatter.c | 134 -------- ext/intl/formatter/formatter.h | 22 -- ext/intl/formatter/formatter.stub.php | 391 +++++++++++++++++++++ ext/intl/formatter/formatter_arginfo.h | 448 ++++++++++++++++++++++++- ext/intl/php_intl.c | 4 - 7 files changed, 838 insertions(+), 163 deletions(-) delete mode 100644 ext/intl/formatter/formatter.c delete mode 100644 ext/intl/formatter/formatter.h diff --git a/ext/intl/config.m4 b/ext/intl/config.m4 index 91a91da20c27c..93e5833fa02f0 100644 --- a/ext/intl/config.m4 +++ b/ext/intl/config.m4 @@ -21,7 +21,6 @@ if test "$PHP_INTL" != "no"; then collator/collator_error.c \ common/common_error.c \ converter/converter.c \ - formatter/formatter.c \ formatter/formatter_main.c \ formatter/formatter_class.c \ formatter/formatter_attr.c \ diff --git a/ext/intl/config.w32 b/ext/intl/config.w32 index 95ac9a108f73a..e072f46979c21 100644 --- a/ext/intl/config.w32 +++ b/ext/intl/config.w32 @@ -28,7 +28,6 @@ if (PHP_INTL != "no") { converter.c \ ", "intl"); ADD_SOURCES(configure_module_dirname + "/formatter", "\ - formatter.c \ formatter_attr.c \ formatter_class.c \ formatter_data.c \ diff --git a/ext/intl/formatter/formatter.c b/ext/intl/formatter/formatter.c deleted file mode 100644 index 451008b5502bd..0000000000000 --- a/ext/intl/formatter/formatter.c +++ /dev/null @@ -1,134 +0,0 @@ -/* - +----------------------------------------------------------------------+ - | This source file is subject to version 3.01 of the PHP license, | - | that is bundled with this package in the file LICENSE, and is | - | available through the world-wide-web at the following url: | - | https://www.php.net/license/3_01.txt | - | If you did not receive a copy of the PHP license and are unable to | - | obtain it through the world-wide-web, please send a note to | - | license@php.net so we can mail you a copy immediately. | - +----------------------------------------------------------------------+ - | Authors: Stanislav Malyshev | - +----------------------------------------------------------------------+ - */ - -#ifdef HAVE_CONFIG_H -#include "config.h" -#endif - -#include -#include -#include - -#include "php_intl.h" -#include "formatter_class.h" -#include "formatter_format.h" - -/* {{{ formatter_register_constants - * Register constants common for the both (OO and procedural) - * APIs. - */ -void formatter_register_constants( INIT_FUNC_ARGS ) -{ - if( NumberFormatter_ce_ptr == NULL) { - zend_error(E_ERROR, "NumberFormatter class not defined"); - } - - #define FORMATTER_EXPOSE_CONST(x) REGISTER_LONG_CONSTANT(#x, x, CONST_PERSISTENT | CONST_CS) - #define FORMATTER_EXPOSE_CLASS_CONST(x) zend_declare_class_constant_long( NumberFormatter_ce_ptr, ZEND_STRS( #x ) - 1, UNUM_##x ); - #define FORMATTER_EXPOSE_CUSTOM_CLASS_CONST(name, value) zend_declare_class_constant_long( NumberFormatter_ce_ptr, ZEND_STRS( name ) - 1, value ); - - /* UNumberFormatStyle constants */ - FORMATTER_EXPOSE_CLASS_CONST( PATTERN_DECIMAL ); - FORMATTER_EXPOSE_CLASS_CONST( DECIMAL ); - FORMATTER_EXPOSE_CLASS_CONST( CURRENCY ); - FORMATTER_EXPOSE_CLASS_CONST( PERCENT ); - FORMATTER_EXPOSE_CLASS_CONST( SCIENTIFIC ); - FORMATTER_EXPOSE_CLASS_CONST( SPELLOUT ); - FORMATTER_EXPOSE_CLASS_CONST( ORDINAL ); - FORMATTER_EXPOSE_CLASS_CONST( DURATION ); - FORMATTER_EXPOSE_CLASS_CONST( PATTERN_RULEBASED ); - FORMATTER_EXPOSE_CLASS_CONST( IGNORE ); -#if U_ICU_VERSION_MAJOR_NUM >= 53 - FORMATTER_EXPOSE_CLASS_CONST( CURRENCY_ACCOUNTING ); -#endif - FORMATTER_EXPOSE_CUSTOM_CLASS_CONST( "DEFAULT_STYLE", UNUM_DEFAULT ); - - /* UNumberFormatRoundingMode */ - FORMATTER_EXPOSE_CLASS_CONST( ROUND_CEILING ); - FORMATTER_EXPOSE_CLASS_CONST( ROUND_FLOOR ); - FORMATTER_EXPOSE_CLASS_CONST( ROUND_DOWN ); - FORMATTER_EXPOSE_CLASS_CONST( ROUND_UP ); - FORMATTER_EXPOSE_CLASS_CONST( ROUND_HALFEVEN ); - FORMATTER_EXPOSE_CLASS_CONST( ROUND_HALFDOWN ); - FORMATTER_EXPOSE_CLASS_CONST( ROUND_HALFUP ); - - /* UNumberFormatPadPosition */ - FORMATTER_EXPOSE_CLASS_CONST( PAD_BEFORE_PREFIX ); - FORMATTER_EXPOSE_CLASS_CONST( PAD_AFTER_PREFIX ); - FORMATTER_EXPOSE_CLASS_CONST( PAD_BEFORE_SUFFIX ); - FORMATTER_EXPOSE_CLASS_CONST( PAD_AFTER_SUFFIX ); - - /* UNumberFormatAttribute */ - FORMATTER_EXPOSE_CLASS_CONST( PARSE_INT_ONLY ); - FORMATTER_EXPOSE_CLASS_CONST( GROUPING_USED ); - FORMATTER_EXPOSE_CLASS_CONST( DECIMAL_ALWAYS_SHOWN ); - FORMATTER_EXPOSE_CLASS_CONST( MAX_INTEGER_DIGITS ); - FORMATTER_EXPOSE_CLASS_CONST( MIN_INTEGER_DIGITS ); - FORMATTER_EXPOSE_CLASS_CONST( INTEGER_DIGITS ); - FORMATTER_EXPOSE_CLASS_CONST( MAX_FRACTION_DIGITS ); - FORMATTER_EXPOSE_CLASS_CONST( MIN_FRACTION_DIGITS ); - FORMATTER_EXPOSE_CLASS_CONST( FRACTION_DIGITS ); - FORMATTER_EXPOSE_CLASS_CONST( MULTIPLIER ); - FORMATTER_EXPOSE_CLASS_CONST( GROUPING_SIZE ); - FORMATTER_EXPOSE_CLASS_CONST( ROUNDING_MODE ); - FORMATTER_EXPOSE_CLASS_CONST( ROUNDING_INCREMENT ); - FORMATTER_EXPOSE_CLASS_CONST( FORMAT_WIDTH ); - FORMATTER_EXPOSE_CLASS_CONST( PADDING_POSITION ); - FORMATTER_EXPOSE_CLASS_CONST( SECONDARY_GROUPING_SIZE ); - FORMATTER_EXPOSE_CLASS_CONST( SIGNIFICANT_DIGITS_USED ); - FORMATTER_EXPOSE_CLASS_CONST( MIN_SIGNIFICANT_DIGITS ); - FORMATTER_EXPOSE_CLASS_CONST( MAX_SIGNIFICANT_DIGITS ); - FORMATTER_EXPOSE_CLASS_CONST( LENIENT_PARSE ); - - /* UNumberFormatTextAttribute */ - FORMATTER_EXPOSE_CLASS_CONST( POSITIVE_PREFIX ); - FORMATTER_EXPOSE_CLASS_CONST( POSITIVE_SUFFIX ); - FORMATTER_EXPOSE_CLASS_CONST( NEGATIVE_PREFIX ); - FORMATTER_EXPOSE_CLASS_CONST( NEGATIVE_SUFFIX ); - FORMATTER_EXPOSE_CLASS_CONST( PADDING_CHARACTER ); - FORMATTER_EXPOSE_CLASS_CONST( CURRENCY_CODE ); - FORMATTER_EXPOSE_CLASS_CONST( DEFAULT_RULESET ); - FORMATTER_EXPOSE_CLASS_CONST( PUBLIC_RULESETS ); - - /* UNumberFormatSymbol */ - FORMATTER_EXPOSE_CLASS_CONST( DECIMAL_SEPARATOR_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( GROUPING_SEPARATOR_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( PATTERN_SEPARATOR_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( PERCENT_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( ZERO_DIGIT_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( DIGIT_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( MINUS_SIGN_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( PLUS_SIGN_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( CURRENCY_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( INTL_CURRENCY_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( MONETARY_SEPARATOR_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( EXPONENTIAL_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( PERMILL_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( PAD_ESCAPE_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( INFINITY_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( NAN_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( SIGNIFICANT_DIGIT_SYMBOL ); - FORMATTER_EXPOSE_CLASS_CONST( MONETARY_GROUPING_SEPARATOR_SYMBOL ); - - FORMATTER_EXPOSE_CUSTOM_CLASS_CONST( "TYPE_DEFAULT", FORMAT_TYPE_DEFAULT ); - FORMATTER_EXPOSE_CUSTOM_CLASS_CONST( "TYPE_INT32", FORMAT_TYPE_INT32 ); - FORMATTER_EXPOSE_CUSTOM_CLASS_CONST( "TYPE_INT64", FORMAT_TYPE_INT64 ); - FORMATTER_EXPOSE_CUSTOM_CLASS_CONST( "TYPE_DOUBLE", FORMAT_TYPE_DOUBLE ); - FORMATTER_EXPOSE_CUSTOM_CLASS_CONST( "TYPE_CURRENCY", FORMAT_TYPE_CURRENCY ); - - #undef FORMATTER_EXPOSE_CUSTOM_CLASS_CONST - #undef FORMATTER_EXPOSE_CLASS_CONST - #undef FORMATTER_EXPOSE_CONST -} -/* }}} */ diff --git a/ext/intl/formatter/formatter.h b/ext/intl/formatter/formatter.h deleted file mode 100644 index 3f1c6da438925..0000000000000 --- a/ext/intl/formatter/formatter.h +++ /dev/null @@ -1,22 +0,0 @@ -/* - +----------------------------------------------------------------------+ - | This source file is subject to version 3.01 of the PHP license, | - | that is bundled with this package in the file LICENSE, and is | - | available through the world-wide-web at the following url: | - | https://www.php.net/license/3_01.txt | - | If you did not receive a copy of the PHP license and are unable to | - | obtain it through the world-wide-web, please send a note to | - | license@php.net so we can mail you a copy immediately. | - +----------------------------------------------------------------------+ - | Authors: Stanislav Malyshev | - +----------------------------------------------------------------------+ - */ - -#ifndef FORMATTER_FORMATTER_H -#define FORMATTER_FORMATTER_H - -#include - -void formatter_register_constants( INIT_FUNC_ARGS ); - -#endif // FORMATTER_FORMATTER_H diff --git a/ext/intl/formatter/formatter.stub.php b/ext/intl/formatter/formatter.stub.php index 6cf101e340694..da6a6e3c5a6c2 100644 --- a/ext/intl/formatter/formatter.stub.php +++ b/ext/intl/formatter/formatter.stub.php @@ -5,6 +5,397 @@ /** @not-serializable */ class NumberFormatter { + /* UNumberFormatStyle constants */ + + /** + * @var int + * @cvalue UNUM_PATTERN_DECIMAL + */ + public const PATTERN_DECIMAL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_DECIMAL + */ + public const DECIMAL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_CURRENCY + */ + public const CURRENCY = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PERCENT + */ + public const PERCENT = UNKNOWN; + /** + * @var int + * @cvalue UNUM_SCIENTIFIC + */ + public const SCIENTIFIC = UNKNOWN; + /** + * @var int + * @cvalue UNUM_SPELLOUT + */ + public const SPELLOUT = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ORDINAL + */ + public const ORDINAL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_DURATION + */ + public const DURATION = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PATTERN_RULEBASED + */ + public const PATTERN_RULEBASED = UNKNOWN; + /** + * @var int + * @cvalue UNUM_IGNORE + */ + public const IGNORE = UNKNOWN; +#if U_ICU_VERSION_MAJOR_NUM >= 53 + /** + * @var int + * @cvalue UNUM_CURRENCY_ACCOUNTING + */ + public const CURRENCY_ACCOUNTING = UNKNOWN; +#endif + /** + * @var int + * @cvalue UNUM_DEFAULT + */ + public const DEFAULT_STYLE = UNKNOWN; + + /* UNumberFormatRoundingMode */ + + /** + * @var int + * @cvalue UNUM_ROUND_CEILING + */ + public const ROUND_CEILING = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ROUND_FLOOR + */ + public const ROUND_FLOOR = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ROUND_DOWN + */ + public const ROUND_DOWN = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ROUND_UP + */ + public const ROUND_UP = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ROUND_HALFEVEN + */ + public const ROUND_HALFEVEN = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ROUND_HALFDOWN + */ + public const ROUND_HALFDOWN = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ROUND_HALFUP + */ + public const ROUND_HALFUP = UNKNOWN; + + /* UNumberFormatPadPosition */ + + /** + * @var int + * @cvalue UNUM_PAD_BEFORE_PREFIX + */ + public const PAD_BEFORE_PREFIX = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PAD_AFTER_PREFIX + */ + public const PAD_AFTER_PREFIX = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PAD_BEFORE_SUFFIX + */ + public const PAD_BEFORE_SUFFIX = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PAD_AFTER_SUFFIX + */ + public const PAD_AFTER_SUFFIX = UNKNOWN; + + /* UNumberFormatAttribute */ + + /** + * @var int + * @cvalue UNUM_PARSE_INT_ONLY + */ + public const PARSE_INT_ONLY = UNKNOWN; + /** + * @var int + * @cvalue UNUM_GROUPING_USED + */ + public const GROUPING_USED = UNKNOWN; + /** + * @var int + * @cvalue UNUM_DECIMAL_ALWAYS_SHOWN + */ + public const DECIMAL_ALWAYS_SHOWN = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MAX_INTEGER_DIGITS + */ + public const MAX_INTEGER_DIGITS = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MIN_INTEGER_DIGITS + */ + public const MIN_INTEGER_DIGITS = UNKNOWN; + /** + * @var int + * @cvalue UNUM_INTEGER_DIGITS + */ + public const INTEGER_DIGITS = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MAX_FRACTION_DIGITS + */ + public const MAX_FRACTION_DIGITS = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MIN_FRACTION_DIGITS + */ + public const MIN_FRACTION_DIGITS = UNKNOWN; + /** + * @var int + * @cvalue UNUM_FRACTION_DIGITS + */ + public const FRACTION_DIGITS = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MULTIPLIER + */ + public const MULTIPLIER = UNKNOWN; + /** + * @var int + * @cvalue UNUM_GROUPING_SIZE + */ + public const GROUPING_SIZE = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ROUNDING_MODE + */ + public const ROUNDING_MODE = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ROUNDING_INCREMENT + */ + public const ROUNDING_INCREMENT = UNKNOWN; + /** + * @var int + * @cvalue UNUM_FORMAT_WIDTH + */ + public const FORMAT_WIDTH = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PADDING_POSITION + */ + public const PADDING_POSITION = UNKNOWN; + /** + * @var int + * @cvalue UNUM_SECONDARY_GROUPING_SIZE + */ + public const SECONDARY_GROUPING_SIZE = UNKNOWN; + /** + * @var int + * @cvalue UNUM_SIGNIFICANT_DIGITS_USED + */ + public const SIGNIFICANT_DIGITS_USED = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MIN_SIGNIFICANT_DIGITS + */ + public const MIN_SIGNIFICANT_DIGITS = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MAX_SIGNIFICANT_DIGITS + */ + public const MAX_SIGNIFICANT_DIGITS = UNKNOWN; + /** + * @var int + * @cvalue UNUM_LENIENT_PARSE + */ + public const LENIENT_PARSE = UNKNOWN; + + /* UNumberFormatTextAttribute */ + + /** + * @var int + * @cvalue UNUM_POSITIVE_PREFIX + */ + public const POSITIVE_PREFIX = UNKNOWN; + /** + * @var int + * @cvalue UNUM_POSITIVE_SUFFIX + */ + public const POSITIVE_SUFFIX = UNKNOWN; + /** + * @var int + * @cvalue UNUM_NEGATIVE_PREFIX + */ + public const NEGATIVE_PREFIX = UNKNOWN; + /** + * @var int + * @cvalue UNUM_NEGATIVE_SUFFIX + */ + public const NEGATIVE_SUFFIX = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PADDING_CHARACTER + */ + public const PADDING_CHARACTER = UNKNOWN; + /** + * @var int + * @cvalue UNUM_CURRENCY_CODE + */ + public const CURRENCY_CODE = UNKNOWN; + /** + * @var int + * @cvalue UNUM_DEFAULT_RULESET + */ + public const DEFAULT_RULESET = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PUBLIC_RULESETS + */ + public const PUBLIC_RULESETS = UNKNOWN; + + /* UNumberFormatSymbol */ + + /** + * @var int + * @cvalue UNUM_DECIMAL_SEPARATOR_SYMBOL + */ + public const DECIMAL_SEPARATOR_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_GROUPING_SEPARATOR_SYMBOL + */ + public const GROUPING_SEPARATOR_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PATTERN_SEPARATOR_SYMBOL + */ + public const PATTERN_SEPARATOR_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PERCENT_SYMBOL + */ + public const PERCENT_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_ZERO_DIGIT_SYMBOL + */ + public const ZERO_DIGIT_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_DIGIT_SYMBOL + */ + public const DIGIT_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MINUS_SIGN_SYMBOL + */ + public const MINUS_SIGN_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PLUS_SIGN_SYMBOL + */ + public const PLUS_SIGN_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_CURRENCY_SYMBOL + */ + public const CURRENCY_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_INTL_CURRENCY_SYMBOL + */ + public const INTL_CURRENCY_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MONETARY_SEPARATOR_SYMBOL + */ + public const MONETARY_SEPARATOR_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_EXPONENTIAL_SYMBOL + */ + public const EXPONENTIAL_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PERMILL_SYMBOL + */ + public const PERMILL_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_PAD_ESCAPE_SYMBOL + */ + public const PAD_ESCAPE_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_INFINITY_SYMBOL + */ + public const INFINITY_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_NAN_SYMBOL + */ + public const NAN_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_SIGNIFICANT_DIGIT_SYMBOL + */ + public const SIGNIFICANT_DIGIT_SYMBOL = UNKNOWN; + /** + * @var int + * @cvalue UNUM_MONETARY_GROUPING_SEPARATOR_SYMBOL + */ + public const MONETARY_GROUPING_SEPARATOR_SYMBOL = UNKNOWN; + + /** + * @var int + * @cvalue FORMAT_TYPE_DEFAULT + */ + public const TYPE_DEFAULT = UNKNOWN; + /** + * @var int + * @cvalue FORMAT_TYPE_INT32 + */ + public const TYPE_INT32 = UNKNOWN; + /** + * @var int + * @cvalue FORMAT_TYPE_INT64 + */ + public const TYPE_INT64 = UNKNOWN; + /** + * @var int + * @cvalue FORMAT_TYPE_DOUBLE + */ + public const TYPE_DOUBLE = UNKNOWN; + /** + * @var int + * @cvalue FORMAT_TYPE_CURRENCY + */ + public const TYPE_CURRENCY = UNKNOWN; + public function __construct(string $locale, int $style, ?string $pattern = null) {} /** diff --git a/ext/intl/formatter/formatter_arginfo.h b/ext/intl/formatter/formatter_arginfo.h index 432ced976bdf6..3488b025c725c 100644 --- a/ext/intl/formatter/formatter_arginfo.h +++ b/ext/intl/formatter/formatter_arginfo.h @@ -1,5 +1,5 @@ /* This is a generated file, edit the .stub.php file instead. - * Stub hash: f76ad76b08b7ca47883659fabfcc0882a2820c43 */ + * Stub hash: de64db0e66d2113dd10c556cd61324a7a7952973 */ ZEND_BEGIN_ARG_INFO_EX(arginfo_class_NumberFormatter___construct, 0, 0, 2) ZEND_ARG_TYPE_INFO(0, locale, IS_STRING, 0) @@ -128,5 +128,451 @@ static zend_class_entry *register_class_NumberFormatter(void) class_entry = zend_register_internal_class_ex(&ce, NULL); class_entry->ce_flags |= ZEND_ACC_NOT_SERIALIZABLE; + zval const_PATTERN_DECIMAL_value; + ZVAL_LONG(&const_PATTERN_DECIMAL_value, UNUM_PATTERN_DECIMAL); + zend_string *const_PATTERN_DECIMAL_name = zend_string_init_interned("PATTERN_DECIMAL", sizeof("PATTERN_DECIMAL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PATTERN_DECIMAL_name, &const_PATTERN_DECIMAL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PATTERN_DECIMAL_name); + + zval const_DECIMAL_value; + ZVAL_LONG(&const_DECIMAL_value, UNUM_DECIMAL); + zend_string *const_DECIMAL_name = zend_string_init_interned("DECIMAL", sizeof("DECIMAL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_DECIMAL_name, &const_DECIMAL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_DECIMAL_name); + + zval const_CURRENCY_value; + ZVAL_LONG(&const_CURRENCY_value, UNUM_CURRENCY); + zend_string *const_CURRENCY_name = zend_string_init_interned("CURRENCY", sizeof("CURRENCY") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_CURRENCY_name, &const_CURRENCY_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_CURRENCY_name); + + zval const_PERCENT_value; + ZVAL_LONG(&const_PERCENT_value, UNUM_PERCENT); + zend_string *const_PERCENT_name = zend_string_init_interned("PERCENT", sizeof("PERCENT") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PERCENT_name, &const_PERCENT_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PERCENT_name); + + zval const_SCIENTIFIC_value; + ZVAL_LONG(&const_SCIENTIFIC_value, UNUM_SCIENTIFIC); + zend_string *const_SCIENTIFIC_name = zend_string_init_interned("SCIENTIFIC", sizeof("SCIENTIFIC") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_SCIENTIFIC_name, &const_SCIENTIFIC_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_SCIENTIFIC_name); + + zval const_SPELLOUT_value; + ZVAL_LONG(&const_SPELLOUT_value, UNUM_SPELLOUT); + zend_string *const_SPELLOUT_name = zend_string_init_interned("SPELLOUT", sizeof("SPELLOUT") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_SPELLOUT_name, &const_SPELLOUT_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_SPELLOUT_name); + + zval const_ORDINAL_value; + ZVAL_LONG(&const_ORDINAL_value, UNUM_ORDINAL); + zend_string *const_ORDINAL_name = zend_string_init_interned("ORDINAL", sizeof("ORDINAL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ORDINAL_name, &const_ORDINAL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ORDINAL_name); + + zval const_DURATION_value; + ZVAL_LONG(&const_DURATION_value, UNUM_DURATION); + zend_string *const_DURATION_name = zend_string_init_interned("DURATION", sizeof("DURATION") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_DURATION_name, &const_DURATION_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_DURATION_name); + + zval const_PATTERN_RULEBASED_value; + ZVAL_LONG(&const_PATTERN_RULEBASED_value, UNUM_PATTERN_RULEBASED); + zend_string *const_PATTERN_RULEBASED_name = zend_string_init_interned("PATTERN_RULEBASED", sizeof("PATTERN_RULEBASED") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PATTERN_RULEBASED_name, &const_PATTERN_RULEBASED_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PATTERN_RULEBASED_name); + + zval const_IGNORE_value; + ZVAL_LONG(&const_IGNORE_value, UNUM_IGNORE); + zend_string *const_IGNORE_name = zend_string_init_interned("IGNORE", sizeof("IGNORE") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_IGNORE_name, &const_IGNORE_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_IGNORE_name); +#if U_ICU_VERSION_MAJOR_NUM >= 53 + + zval const_CURRENCY_ACCOUNTING_value; + ZVAL_LONG(&const_CURRENCY_ACCOUNTING_value, UNUM_CURRENCY_ACCOUNTING); + zend_string *const_CURRENCY_ACCOUNTING_name = zend_string_init_interned("CURRENCY_ACCOUNTING", sizeof("CURRENCY_ACCOUNTING") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_CURRENCY_ACCOUNTING_name, &const_CURRENCY_ACCOUNTING_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_CURRENCY_ACCOUNTING_name); +#endif + + zval const_DEFAULT_STYLE_value; + ZVAL_LONG(&const_DEFAULT_STYLE_value, UNUM_DEFAULT); + zend_string *const_DEFAULT_STYLE_name = zend_string_init_interned("DEFAULT_STYLE", sizeof("DEFAULT_STYLE") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_DEFAULT_STYLE_name, &const_DEFAULT_STYLE_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_DEFAULT_STYLE_name); + + zval const_ROUND_CEILING_value; + ZVAL_LONG(&const_ROUND_CEILING_value, UNUM_ROUND_CEILING); + zend_string *const_ROUND_CEILING_name = zend_string_init_interned("ROUND_CEILING", sizeof("ROUND_CEILING") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ROUND_CEILING_name, &const_ROUND_CEILING_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ROUND_CEILING_name); + + zval const_ROUND_FLOOR_value; + ZVAL_LONG(&const_ROUND_FLOOR_value, UNUM_ROUND_FLOOR); + zend_string *const_ROUND_FLOOR_name = zend_string_init_interned("ROUND_FLOOR", sizeof("ROUND_FLOOR") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ROUND_FLOOR_name, &const_ROUND_FLOOR_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ROUND_FLOOR_name); + + zval const_ROUND_DOWN_value; + ZVAL_LONG(&const_ROUND_DOWN_value, UNUM_ROUND_DOWN); + zend_string *const_ROUND_DOWN_name = zend_string_init_interned("ROUND_DOWN", sizeof("ROUND_DOWN") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ROUND_DOWN_name, &const_ROUND_DOWN_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ROUND_DOWN_name); + + zval const_ROUND_UP_value; + ZVAL_LONG(&const_ROUND_UP_value, UNUM_ROUND_UP); + zend_string *const_ROUND_UP_name = zend_string_init_interned("ROUND_UP", sizeof("ROUND_UP") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ROUND_UP_name, &const_ROUND_UP_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ROUND_UP_name); + + zval const_ROUND_HALFEVEN_value; + ZVAL_LONG(&const_ROUND_HALFEVEN_value, UNUM_ROUND_HALFEVEN); + zend_string *const_ROUND_HALFEVEN_name = zend_string_init_interned("ROUND_HALFEVEN", sizeof("ROUND_HALFEVEN") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ROUND_HALFEVEN_name, &const_ROUND_HALFEVEN_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ROUND_HALFEVEN_name); + + zval const_ROUND_HALFDOWN_value; + ZVAL_LONG(&const_ROUND_HALFDOWN_value, UNUM_ROUND_HALFDOWN); + zend_string *const_ROUND_HALFDOWN_name = zend_string_init_interned("ROUND_HALFDOWN", sizeof("ROUND_HALFDOWN") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ROUND_HALFDOWN_name, &const_ROUND_HALFDOWN_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ROUND_HALFDOWN_name); + + zval const_ROUND_HALFUP_value; + ZVAL_LONG(&const_ROUND_HALFUP_value, UNUM_ROUND_HALFUP); + zend_string *const_ROUND_HALFUP_name = zend_string_init_interned("ROUND_HALFUP", sizeof("ROUND_HALFUP") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ROUND_HALFUP_name, &const_ROUND_HALFUP_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ROUND_HALFUP_name); + + zval const_PAD_BEFORE_PREFIX_value; + ZVAL_LONG(&const_PAD_BEFORE_PREFIX_value, UNUM_PAD_BEFORE_PREFIX); + zend_string *const_PAD_BEFORE_PREFIX_name = zend_string_init_interned("PAD_BEFORE_PREFIX", sizeof("PAD_BEFORE_PREFIX") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PAD_BEFORE_PREFIX_name, &const_PAD_BEFORE_PREFIX_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PAD_BEFORE_PREFIX_name); + + zval const_PAD_AFTER_PREFIX_value; + ZVAL_LONG(&const_PAD_AFTER_PREFIX_value, UNUM_PAD_AFTER_PREFIX); + zend_string *const_PAD_AFTER_PREFIX_name = zend_string_init_interned("PAD_AFTER_PREFIX", sizeof("PAD_AFTER_PREFIX") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PAD_AFTER_PREFIX_name, &const_PAD_AFTER_PREFIX_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PAD_AFTER_PREFIX_name); + + zval const_PAD_BEFORE_SUFFIX_value; + ZVAL_LONG(&const_PAD_BEFORE_SUFFIX_value, UNUM_PAD_BEFORE_SUFFIX); + zend_string *const_PAD_BEFORE_SUFFIX_name = zend_string_init_interned("PAD_BEFORE_SUFFIX", sizeof("PAD_BEFORE_SUFFIX") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PAD_BEFORE_SUFFIX_name, &const_PAD_BEFORE_SUFFIX_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PAD_BEFORE_SUFFIX_name); + + zval const_PAD_AFTER_SUFFIX_value; + ZVAL_LONG(&const_PAD_AFTER_SUFFIX_value, UNUM_PAD_AFTER_SUFFIX); + zend_string *const_PAD_AFTER_SUFFIX_name = zend_string_init_interned("PAD_AFTER_SUFFIX", sizeof("PAD_AFTER_SUFFIX") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PAD_AFTER_SUFFIX_name, &const_PAD_AFTER_SUFFIX_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PAD_AFTER_SUFFIX_name); + + zval const_PARSE_INT_ONLY_value; + ZVAL_LONG(&const_PARSE_INT_ONLY_value, UNUM_PARSE_INT_ONLY); + zend_string *const_PARSE_INT_ONLY_name = zend_string_init_interned("PARSE_INT_ONLY", sizeof("PARSE_INT_ONLY") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PARSE_INT_ONLY_name, &const_PARSE_INT_ONLY_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PARSE_INT_ONLY_name); + + zval const_GROUPING_USED_value; + ZVAL_LONG(&const_GROUPING_USED_value, UNUM_GROUPING_USED); + zend_string *const_GROUPING_USED_name = zend_string_init_interned("GROUPING_USED", sizeof("GROUPING_USED") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_GROUPING_USED_name, &const_GROUPING_USED_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_GROUPING_USED_name); + + zval const_DECIMAL_ALWAYS_SHOWN_value; + ZVAL_LONG(&const_DECIMAL_ALWAYS_SHOWN_value, UNUM_DECIMAL_ALWAYS_SHOWN); + zend_string *const_DECIMAL_ALWAYS_SHOWN_name = zend_string_init_interned("DECIMAL_ALWAYS_SHOWN", sizeof("DECIMAL_ALWAYS_SHOWN") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_DECIMAL_ALWAYS_SHOWN_name, &const_DECIMAL_ALWAYS_SHOWN_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_DECIMAL_ALWAYS_SHOWN_name); + + zval const_MAX_INTEGER_DIGITS_value; + ZVAL_LONG(&const_MAX_INTEGER_DIGITS_value, UNUM_MAX_INTEGER_DIGITS); + zend_string *const_MAX_INTEGER_DIGITS_name = zend_string_init_interned("MAX_INTEGER_DIGITS", sizeof("MAX_INTEGER_DIGITS") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MAX_INTEGER_DIGITS_name, &const_MAX_INTEGER_DIGITS_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MAX_INTEGER_DIGITS_name); + + zval const_MIN_INTEGER_DIGITS_value; + ZVAL_LONG(&const_MIN_INTEGER_DIGITS_value, UNUM_MIN_INTEGER_DIGITS); + zend_string *const_MIN_INTEGER_DIGITS_name = zend_string_init_interned("MIN_INTEGER_DIGITS", sizeof("MIN_INTEGER_DIGITS") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MIN_INTEGER_DIGITS_name, &const_MIN_INTEGER_DIGITS_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MIN_INTEGER_DIGITS_name); + + zval const_INTEGER_DIGITS_value; + ZVAL_LONG(&const_INTEGER_DIGITS_value, UNUM_INTEGER_DIGITS); + zend_string *const_INTEGER_DIGITS_name = zend_string_init_interned("INTEGER_DIGITS", sizeof("INTEGER_DIGITS") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_INTEGER_DIGITS_name, &const_INTEGER_DIGITS_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_INTEGER_DIGITS_name); + + zval const_MAX_FRACTION_DIGITS_value; + ZVAL_LONG(&const_MAX_FRACTION_DIGITS_value, UNUM_MAX_FRACTION_DIGITS); + zend_string *const_MAX_FRACTION_DIGITS_name = zend_string_init_interned("MAX_FRACTION_DIGITS", sizeof("MAX_FRACTION_DIGITS") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MAX_FRACTION_DIGITS_name, &const_MAX_FRACTION_DIGITS_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MAX_FRACTION_DIGITS_name); + + zval const_MIN_FRACTION_DIGITS_value; + ZVAL_LONG(&const_MIN_FRACTION_DIGITS_value, UNUM_MIN_FRACTION_DIGITS); + zend_string *const_MIN_FRACTION_DIGITS_name = zend_string_init_interned("MIN_FRACTION_DIGITS", sizeof("MIN_FRACTION_DIGITS") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MIN_FRACTION_DIGITS_name, &const_MIN_FRACTION_DIGITS_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MIN_FRACTION_DIGITS_name); + + zval const_FRACTION_DIGITS_value; + ZVAL_LONG(&const_FRACTION_DIGITS_value, UNUM_FRACTION_DIGITS); + zend_string *const_FRACTION_DIGITS_name = zend_string_init_interned("FRACTION_DIGITS", sizeof("FRACTION_DIGITS") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_FRACTION_DIGITS_name, &const_FRACTION_DIGITS_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_FRACTION_DIGITS_name); + + zval const_MULTIPLIER_value; + ZVAL_LONG(&const_MULTIPLIER_value, UNUM_MULTIPLIER); + zend_string *const_MULTIPLIER_name = zend_string_init_interned("MULTIPLIER", sizeof("MULTIPLIER") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MULTIPLIER_name, &const_MULTIPLIER_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MULTIPLIER_name); + + zval const_GROUPING_SIZE_value; + ZVAL_LONG(&const_GROUPING_SIZE_value, UNUM_GROUPING_SIZE); + zend_string *const_GROUPING_SIZE_name = zend_string_init_interned("GROUPING_SIZE", sizeof("GROUPING_SIZE") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_GROUPING_SIZE_name, &const_GROUPING_SIZE_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_GROUPING_SIZE_name); + + zval const_ROUNDING_MODE_value; + ZVAL_LONG(&const_ROUNDING_MODE_value, UNUM_ROUNDING_MODE); + zend_string *const_ROUNDING_MODE_name = zend_string_init_interned("ROUNDING_MODE", sizeof("ROUNDING_MODE") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ROUNDING_MODE_name, &const_ROUNDING_MODE_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ROUNDING_MODE_name); + + zval const_ROUNDING_INCREMENT_value; + ZVAL_LONG(&const_ROUNDING_INCREMENT_value, UNUM_ROUNDING_INCREMENT); + zend_string *const_ROUNDING_INCREMENT_name = zend_string_init_interned("ROUNDING_INCREMENT", sizeof("ROUNDING_INCREMENT") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ROUNDING_INCREMENT_name, &const_ROUNDING_INCREMENT_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ROUNDING_INCREMENT_name); + + zval const_FORMAT_WIDTH_value; + ZVAL_LONG(&const_FORMAT_WIDTH_value, UNUM_FORMAT_WIDTH); + zend_string *const_FORMAT_WIDTH_name = zend_string_init_interned("FORMAT_WIDTH", sizeof("FORMAT_WIDTH") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_FORMAT_WIDTH_name, &const_FORMAT_WIDTH_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_FORMAT_WIDTH_name); + + zval const_PADDING_POSITION_value; + ZVAL_LONG(&const_PADDING_POSITION_value, UNUM_PADDING_POSITION); + zend_string *const_PADDING_POSITION_name = zend_string_init_interned("PADDING_POSITION", sizeof("PADDING_POSITION") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PADDING_POSITION_name, &const_PADDING_POSITION_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PADDING_POSITION_name); + + zval const_SECONDARY_GROUPING_SIZE_value; + ZVAL_LONG(&const_SECONDARY_GROUPING_SIZE_value, UNUM_SECONDARY_GROUPING_SIZE); + zend_string *const_SECONDARY_GROUPING_SIZE_name = zend_string_init_interned("SECONDARY_GROUPING_SIZE", sizeof("SECONDARY_GROUPING_SIZE") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_SECONDARY_GROUPING_SIZE_name, &const_SECONDARY_GROUPING_SIZE_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_SECONDARY_GROUPING_SIZE_name); + + zval const_SIGNIFICANT_DIGITS_USED_value; + ZVAL_LONG(&const_SIGNIFICANT_DIGITS_USED_value, UNUM_SIGNIFICANT_DIGITS_USED); + zend_string *const_SIGNIFICANT_DIGITS_USED_name = zend_string_init_interned("SIGNIFICANT_DIGITS_USED", sizeof("SIGNIFICANT_DIGITS_USED") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_SIGNIFICANT_DIGITS_USED_name, &const_SIGNIFICANT_DIGITS_USED_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_SIGNIFICANT_DIGITS_USED_name); + + zval const_MIN_SIGNIFICANT_DIGITS_value; + ZVAL_LONG(&const_MIN_SIGNIFICANT_DIGITS_value, UNUM_MIN_SIGNIFICANT_DIGITS); + zend_string *const_MIN_SIGNIFICANT_DIGITS_name = zend_string_init_interned("MIN_SIGNIFICANT_DIGITS", sizeof("MIN_SIGNIFICANT_DIGITS") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MIN_SIGNIFICANT_DIGITS_name, &const_MIN_SIGNIFICANT_DIGITS_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MIN_SIGNIFICANT_DIGITS_name); + + zval const_MAX_SIGNIFICANT_DIGITS_value; + ZVAL_LONG(&const_MAX_SIGNIFICANT_DIGITS_value, UNUM_MAX_SIGNIFICANT_DIGITS); + zend_string *const_MAX_SIGNIFICANT_DIGITS_name = zend_string_init_interned("MAX_SIGNIFICANT_DIGITS", sizeof("MAX_SIGNIFICANT_DIGITS") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MAX_SIGNIFICANT_DIGITS_name, &const_MAX_SIGNIFICANT_DIGITS_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MAX_SIGNIFICANT_DIGITS_name); + + zval const_LENIENT_PARSE_value; + ZVAL_LONG(&const_LENIENT_PARSE_value, UNUM_LENIENT_PARSE); + zend_string *const_LENIENT_PARSE_name = zend_string_init_interned("LENIENT_PARSE", sizeof("LENIENT_PARSE") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_LENIENT_PARSE_name, &const_LENIENT_PARSE_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_LENIENT_PARSE_name); + + zval const_POSITIVE_PREFIX_value; + ZVAL_LONG(&const_POSITIVE_PREFIX_value, UNUM_POSITIVE_PREFIX); + zend_string *const_POSITIVE_PREFIX_name = zend_string_init_interned("POSITIVE_PREFIX", sizeof("POSITIVE_PREFIX") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_POSITIVE_PREFIX_name, &const_POSITIVE_PREFIX_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_POSITIVE_PREFIX_name); + + zval const_POSITIVE_SUFFIX_value; + ZVAL_LONG(&const_POSITIVE_SUFFIX_value, UNUM_POSITIVE_SUFFIX); + zend_string *const_POSITIVE_SUFFIX_name = zend_string_init_interned("POSITIVE_SUFFIX", sizeof("POSITIVE_SUFFIX") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_POSITIVE_SUFFIX_name, &const_POSITIVE_SUFFIX_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_POSITIVE_SUFFIX_name); + + zval const_NEGATIVE_PREFIX_value; + ZVAL_LONG(&const_NEGATIVE_PREFIX_value, UNUM_NEGATIVE_PREFIX); + zend_string *const_NEGATIVE_PREFIX_name = zend_string_init_interned("NEGATIVE_PREFIX", sizeof("NEGATIVE_PREFIX") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_NEGATIVE_PREFIX_name, &const_NEGATIVE_PREFIX_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_NEGATIVE_PREFIX_name); + + zval const_NEGATIVE_SUFFIX_value; + ZVAL_LONG(&const_NEGATIVE_SUFFIX_value, UNUM_NEGATIVE_SUFFIX); + zend_string *const_NEGATIVE_SUFFIX_name = zend_string_init_interned("NEGATIVE_SUFFIX", sizeof("NEGATIVE_SUFFIX") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_NEGATIVE_SUFFIX_name, &const_NEGATIVE_SUFFIX_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_NEGATIVE_SUFFIX_name); + + zval const_PADDING_CHARACTER_value; + ZVAL_LONG(&const_PADDING_CHARACTER_value, UNUM_PADDING_CHARACTER); + zend_string *const_PADDING_CHARACTER_name = zend_string_init_interned("PADDING_CHARACTER", sizeof("PADDING_CHARACTER") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PADDING_CHARACTER_name, &const_PADDING_CHARACTER_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PADDING_CHARACTER_name); + + zval const_CURRENCY_CODE_value; + ZVAL_LONG(&const_CURRENCY_CODE_value, UNUM_CURRENCY_CODE); + zend_string *const_CURRENCY_CODE_name = zend_string_init_interned("CURRENCY_CODE", sizeof("CURRENCY_CODE") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_CURRENCY_CODE_name, &const_CURRENCY_CODE_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_CURRENCY_CODE_name); + + zval const_DEFAULT_RULESET_value; + ZVAL_LONG(&const_DEFAULT_RULESET_value, UNUM_DEFAULT_RULESET); + zend_string *const_DEFAULT_RULESET_name = zend_string_init_interned("DEFAULT_RULESET", sizeof("DEFAULT_RULESET") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_DEFAULT_RULESET_name, &const_DEFAULT_RULESET_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_DEFAULT_RULESET_name); + + zval const_PUBLIC_RULESETS_value; + ZVAL_LONG(&const_PUBLIC_RULESETS_value, UNUM_PUBLIC_RULESETS); + zend_string *const_PUBLIC_RULESETS_name = zend_string_init_interned("PUBLIC_RULESETS", sizeof("PUBLIC_RULESETS") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PUBLIC_RULESETS_name, &const_PUBLIC_RULESETS_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PUBLIC_RULESETS_name); + + zval const_DECIMAL_SEPARATOR_SYMBOL_value; + ZVAL_LONG(&const_DECIMAL_SEPARATOR_SYMBOL_value, UNUM_DECIMAL_SEPARATOR_SYMBOL); + zend_string *const_DECIMAL_SEPARATOR_SYMBOL_name = zend_string_init_interned("DECIMAL_SEPARATOR_SYMBOL", sizeof("DECIMAL_SEPARATOR_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_DECIMAL_SEPARATOR_SYMBOL_name, &const_DECIMAL_SEPARATOR_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_DECIMAL_SEPARATOR_SYMBOL_name); + + zval const_GROUPING_SEPARATOR_SYMBOL_value; + ZVAL_LONG(&const_GROUPING_SEPARATOR_SYMBOL_value, UNUM_GROUPING_SEPARATOR_SYMBOL); + zend_string *const_GROUPING_SEPARATOR_SYMBOL_name = zend_string_init_interned("GROUPING_SEPARATOR_SYMBOL", sizeof("GROUPING_SEPARATOR_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_GROUPING_SEPARATOR_SYMBOL_name, &const_GROUPING_SEPARATOR_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_GROUPING_SEPARATOR_SYMBOL_name); + + zval const_PATTERN_SEPARATOR_SYMBOL_value; + ZVAL_LONG(&const_PATTERN_SEPARATOR_SYMBOL_value, UNUM_PATTERN_SEPARATOR_SYMBOL); + zend_string *const_PATTERN_SEPARATOR_SYMBOL_name = zend_string_init_interned("PATTERN_SEPARATOR_SYMBOL", sizeof("PATTERN_SEPARATOR_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PATTERN_SEPARATOR_SYMBOL_name, &const_PATTERN_SEPARATOR_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PATTERN_SEPARATOR_SYMBOL_name); + + zval const_PERCENT_SYMBOL_value; + ZVAL_LONG(&const_PERCENT_SYMBOL_value, UNUM_PERCENT_SYMBOL); + zend_string *const_PERCENT_SYMBOL_name = zend_string_init_interned("PERCENT_SYMBOL", sizeof("PERCENT_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PERCENT_SYMBOL_name, &const_PERCENT_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PERCENT_SYMBOL_name); + + zval const_ZERO_DIGIT_SYMBOL_value; + ZVAL_LONG(&const_ZERO_DIGIT_SYMBOL_value, UNUM_ZERO_DIGIT_SYMBOL); + zend_string *const_ZERO_DIGIT_SYMBOL_name = zend_string_init_interned("ZERO_DIGIT_SYMBOL", sizeof("ZERO_DIGIT_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_ZERO_DIGIT_SYMBOL_name, &const_ZERO_DIGIT_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_ZERO_DIGIT_SYMBOL_name); + + zval const_DIGIT_SYMBOL_value; + ZVAL_LONG(&const_DIGIT_SYMBOL_value, UNUM_DIGIT_SYMBOL); + zend_string *const_DIGIT_SYMBOL_name = zend_string_init_interned("DIGIT_SYMBOL", sizeof("DIGIT_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_DIGIT_SYMBOL_name, &const_DIGIT_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_DIGIT_SYMBOL_name); + + zval const_MINUS_SIGN_SYMBOL_value; + ZVAL_LONG(&const_MINUS_SIGN_SYMBOL_value, UNUM_MINUS_SIGN_SYMBOL); + zend_string *const_MINUS_SIGN_SYMBOL_name = zend_string_init_interned("MINUS_SIGN_SYMBOL", sizeof("MINUS_SIGN_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MINUS_SIGN_SYMBOL_name, &const_MINUS_SIGN_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MINUS_SIGN_SYMBOL_name); + + zval const_PLUS_SIGN_SYMBOL_value; + ZVAL_LONG(&const_PLUS_SIGN_SYMBOL_value, UNUM_PLUS_SIGN_SYMBOL); + zend_string *const_PLUS_SIGN_SYMBOL_name = zend_string_init_interned("PLUS_SIGN_SYMBOL", sizeof("PLUS_SIGN_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PLUS_SIGN_SYMBOL_name, &const_PLUS_SIGN_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PLUS_SIGN_SYMBOL_name); + + zval const_CURRENCY_SYMBOL_value; + ZVAL_LONG(&const_CURRENCY_SYMBOL_value, UNUM_CURRENCY_SYMBOL); + zend_string *const_CURRENCY_SYMBOL_name = zend_string_init_interned("CURRENCY_SYMBOL", sizeof("CURRENCY_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_CURRENCY_SYMBOL_name, &const_CURRENCY_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_CURRENCY_SYMBOL_name); + + zval const_INTL_CURRENCY_SYMBOL_value; + ZVAL_LONG(&const_INTL_CURRENCY_SYMBOL_value, UNUM_INTL_CURRENCY_SYMBOL); + zend_string *const_INTL_CURRENCY_SYMBOL_name = zend_string_init_interned("INTL_CURRENCY_SYMBOL", sizeof("INTL_CURRENCY_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_INTL_CURRENCY_SYMBOL_name, &const_INTL_CURRENCY_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_INTL_CURRENCY_SYMBOL_name); + + zval const_MONETARY_SEPARATOR_SYMBOL_value; + ZVAL_LONG(&const_MONETARY_SEPARATOR_SYMBOL_value, UNUM_MONETARY_SEPARATOR_SYMBOL); + zend_string *const_MONETARY_SEPARATOR_SYMBOL_name = zend_string_init_interned("MONETARY_SEPARATOR_SYMBOL", sizeof("MONETARY_SEPARATOR_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MONETARY_SEPARATOR_SYMBOL_name, &const_MONETARY_SEPARATOR_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MONETARY_SEPARATOR_SYMBOL_name); + + zval const_EXPONENTIAL_SYMBOL_value; + ZVAL_LONG(&const_EXPONENTIAL_SYMBOL_value, UNUM_EXPONENTIAL_SYMBOL); + zend_string *const_EXPONENTIAL_SYMBOL_name = zend_string_init_interned("EXPONENTIAL_SYMBOL", sizeof("EXPONENTIAL_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_EXPONENTIAL_SYMBOL_name, &const_EXPONENTIAL_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_EXPONENTIAL_SYMBOL_name); + + zval const_PERMILL_SYMBOL_value; + ZVAL_LONG(&const_PERMILL_SYMBOL_value, UNUM_PERMILL_SYMBOL); + zend_string *const_PERMILL_SYMBOL_name = zend_string_init_interned("PERMILL_SYMBOL", sizeof("PERMILL_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PERMILL_SYMBOL_name, &const_PERMILL_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PERMILL_SYMBOL_name); + + zval const_PAD_ESCAPE_SYMBOL_value; + ZVAL_LONG(&const_PAD_ESCAPE_SYMBOL_value, UNUM_PAD_ESCAPE_SYMBOL); + zend_string *const_PAD_ESCAPE_SYMBOL_name = zend_string_init_interned("PAD_ESCAPE_SYMBOL", sizeof("PAD_ESCAPE_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_PAD_ESCAPE_SYMBOL_name, &const_PAD_ESCAPE_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_PAD_ESCAPE_SYMBOL_name); + + zval const_INFINITY_SYMBOL_value; + ZVAL_LONG(&const_INFINITY_SYMBOL_value, UNUM_INFINITY_SYMBOL); + zend_string *const_INFINITY_SYMBOL_name = zend_string_init_interned("INFINITY_SYMBOL", sizeof("INFINITY_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_INFINITY_SYMBOL_name, &const_INFINITY_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_INFINITY_SYMBOL_name); + + zval const_NAN_SYMBOL_value; + ZVAL_LONG(&const_NAN_SYMBOL_value, UNUM_NAN_SYMBOL); + zend_string *const_NAN_SYMBOL_name = zend_string_init_interned("NAN_SYMBOL", sizeof("NAN_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_NAN_SYMBOL_name, &const_NAN_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_NAN_SYMBOL_name); + + zval const_SIGNIFICANT_DIGIT_SYMBOL_value; + ZVAL_LONG(&const_SIGNIFICANT_DIGIT_SYMBOL_value, UNUM_SIGNIFICANT_DIGIT_SYMBOL); + zend_string *const_SIGNIFICANT_DIGIT_SYMBOL_name = zend_string_init_interned("SIGNIFICANT_DIGIT_SYMBOL", sizeof("SIGNIFICANT_DIGIT_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_SIGNIFICANT_DIGIT_SYMBOL_name, &const_SIGNIFICANT_DIGIT_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_SIGNIFICANT_DIGIT_SYMBOL_name); + + zval const_MONETARY_GROUPING_SEPARATOR_SYMBOL_value; + ZVAL_LONG(&const_MONETARY_GROUPING_SEPARATOR_SYMBOL_value, UNUM_MONETARY_GROUPING_SEPARATOR_SYMBOL); + zend_string *const_MONETARY_GROUPING_SEPARATOR_SYMBOL_name = zend_string_init_interned("MONETARY_GROUPING_SEPARATOR_SYMBOL", sizeof("MONETARY_GROUPING_SEPARATOR_SYMBOL") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_MONETARY_GROUPING_SEPARATOR_SYMBOL_name, &const_MONETARY_GROUPING_SEPARATOR_SYMBOL_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_MONETARY_GROUPING_SEPARATOR_SYMBOL_name); + + zval const_TYPE_DEFAULT_value; + ZVAL_LONG(&const_TYPE_DEFAULT_value, FORMAT_TYPE_DEFAULT); + zend_string *const_TYPE_DEFAULT_name = zend_string_init_interned("TYPE_DEFAULT", sizeof("TYPE_DEFAULT") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_TYPE_DEFAULT_name, &const_TYPE_DEFAULT_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_TYPE_DEFAULT_name); + + zval const_TYPE_INT32_value; + ZVAL_LONG(&const_TYPE_INT32_value, FORMAT_TYPE_INT32); + zend_string *const_TYPE_INT32_name = zend_string_init_interned("TYPE_INT32", sizeof("TYPE_INT32") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_TYPE_INT32_name, &const_TYPE_INT32_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_TYPE_INT32_name); + + zval const_TYPE_INT64_value; + ZVAL_LONG(&const_TYPE_INT64_value, FORMAT_TYPE_INT64); + zend_string *const_TYPE_INT64_name = zend_string_init_interned("TYPE_INT64", sizeof("TYPE_INT64") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_TYPE_INT64_name, &const_TYPE_INT64_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_TYPE_INT64_name); + + zval const_TYPE_DOUBLE_value; + ZVAL_LONG(&const_TYPE_DOUBLE_value, FORMAT_TYPE_DOUBLE); + zend_string *const_TYPE_DOUBLE_name = zend_string_init_interned("TYPE_DOUBLE", sizeof("TYPE_DOUBLE") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_TYPE_DOUBLE_name, &const_TYPE_DOUBLE_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_TYPE_DOUBLE_name); + + zval const_TYPE_CURRENCY_value; + ZVAL_LONG(&const_TYPE_CURRENCY_value, FORMAT_TYPE_CURRENCY); + zend_string *const_TYPE_CURRENCY_name = zend_string_init_interned("TYPE_CURRENCY", sizeof("TYPE_CURRENCY") - 1, 1); + zend_declare_class_constant_ex(class_entry, const_TYPE_CURRENCY_name, &const_TYPE_CURRENCY_value, ZEND_ACC_PUBLIC, NULL); + zend_string_release(const_TYPE_CURRENCY_name); + return class_entry; } diff --git a/ext/intl/php_intl.c b/ext/intl/php_intl.c index 2fa47e46726a8..e08eea8dc6876 100644 --- a/ext/intl/php_intl.c +++ b/ext/intl/php_intl.c @@ -29,7 +29,6 @@ #include "converter/converter.h" -#include "formatter/formatter.h" #include "formatter/formatter_class.h" #include "formatter/formatter_format.h" @@ -157,9 +156,6 @@ PHP_MINIT_FUNCTION( intl ) /* Register 'NumberFormatter' PHP class */ formatter_register_class( ); - /* Expose NumberFormatter constants to PHP scripts */ - formatter_register_constants( INIT_FUNC_ARGS_PASSTHRU ); - /* Register 'Normalizer' PHP class */ normalizer_register_Normalizer_class( );