php/archived-php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2026-04-03 06:02:23 +02:00
Code Issues Packages Projects Releases Wiki Activity

Declare ext/intl constants in stubs - part 3 (#9233)

Browse Source
This commit is contained in:
Máté Kocsis
2022-08-08 08:28:40 +02:00
committed by GitHub
parent 80197c59ec
commit 163a278a02
7 changed files with 838 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
ext/intl/config.m4
View File

@@ -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 \

1
ext/intl/config.w32
View File

@@ -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 \

134
ext/intl/formatter/formatter.c
View File

@@ -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 <stas@zend.com> |
+----------------------------------------------------------------------+
*/
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#include <unicode/utypes.h>
#include <unicode/unum.h>
#include <unicode/ustring.h>
#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
}
/* }}} */

22
ext/intl/formatter/formatter.h
View File

@@ -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 <stas@zend.com> |
+----------------------------------------------------------------------+
*/
#ifndef FORMATTER_FORMATTER_H
#define FORMATTER_FORMATTER_H
#include <php.h>
void formatter_register_constants( INIT_FUNC_ARGS );
#endif // FORMATTER_FORMATTER_H

391
ext/intl/formatter/formatter.stub.php
View File

@@ -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) {}
/**

448
ext/intl/formatter/formatter_arginfo.h generated
View File

@@ -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;
}

4
ext/intl/php_intl.c
View File

@@ -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( );