/* }}} */
/** {{{ Throwable method definition */
-const zend_function_entry zend_funcs_throwable[] = {
+static const zend_function_entry zend_funcs_throwable[] = {
ZEND_ABSTRACT_ME(throwable, getMessage, NULL)
ZEND_ABSTRACT_ME(throwable, getCode, NULL)
ZEND_ABSTRACT_ME(throwable, getFile, NULL)
/* }}}*/
/* {{{ function tables */
-const zend_function_entry zend_funcs_aggregate[] = {
+static const zend_function_entry zend_funcs_aggregate[] = {
ZEND_ABSTRACT_ME(iterator, getIterator, NULL)
ZEND_FE_END
};
-const zend_function_entry zend_funcs_iterator[] = {
+static const zend_function_entry zend_funcs_iterator[] = {
ZEND_ABSTRACT_ME(iterator, current, NULL)
ZEND_ABSTRACT_ME(iterator, next, NULL)
ZEND_ABSTRACT_ME(iterator, key, NULL)
ZEND_FE_END
};
-const zend_function_entry *zend_funcs_traversable = NULL;
+static const zend_function_entry *zend_funcs_traversable = NULL;
ZEND_BEGIN_ARG_INFO_EX(arginfo_arrayaccess_offset, 0, 0, 1)
ZEND_ARG_INFO(0, offset)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
-const zend_function_entry zend_funcs_arrayaccess[] = {
+static const zend_function_entry zend_funcs_arrayaccess[] = {
ZEND_ABSTRACT_ME(arrayaccess, offsetExists, arginfo_arrayaccess_offset)
ZEND_ABSTRACT_ME(arrayaccess, offsetGet, arginfo_arrayaccess_offset_get)
ZEND_ABSTRACT_ME(arrayaccess, offsetSet, arginfo_arrayaccess_offset_value)
ZEND_ARG_INFO(0, serialized)
ZEND_END_ARG_INFO()
-const zend_function_entry zend_funcs_serializable[] = {
+static const zend_function_entry zend_funcs_serializable[] = {
ZEND_ABSTRACT_ME(serializable, serialize, NULL)
ZEND_FENTRY(unserialize, NULL, arginfo_serializable_serialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT|ZEND_ACC_CTOR)
ZEND_FE_END
ZEND_BEGIN_ARG_INFO(arginfo_countable_count, 0)
ZEND_END_ARG_INFO()
-const zend_function_entry zend_funcs_countable[] = {
+static const zend_function_entry zend_funcs_countable[] = {
ZEND_ABSTRACT_ME(Countable, count, arginfo_countable_count)
ZEND_FE_END
};
static const void **zend_opcode_handlers;
static int zend_handlers_count;
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
-static const void **zend_opcode_handler_funcs;
+static const void * const * zend_opcode_handler_funcs;
static zend_op hybrid_halt_op;
#endif
static const void *zend_vm_get_opcode_handler(zend_uchar opcode, const zend_op* op);
#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)
if (UNEXPECTED(execute_data == NULL)) {
- static const void* labels[] = {
+ static const void * const labels[] = {
(void*)&&ZEND_NOP_SPEC_LABEL,
(void*)&&ZEND_ADD_SPEC_CONST_CONST_LABEL,
(void*)&&ZEND_ADD_SPEC_CONST_TMPVAR_LABEL,
void zend_init_opcodes_handlers(void)
{
- static const void *labels[] = {
+ static const void * const labels[] = {
ZEND_NOP_SPEC_HANDLER,
ZEND_ADD_SPEC_CONST_CONST_HANDLER,
ZEND_ADD_SPEC_CONST_TMPVAR_HANDLER,
out($f,"static int zend_handlers_count;\n");
if ($kind == ZEND_VM_KIND_HYBRID) {
out($f,"#if (ZEND_VM_KIND == ZEND_VM_KIND_HYBRID)\n");
- out($f,"static const void **zend_opcode_handler_funcs;\n");
+ out($f,"static const void * const * zend_opcode_handler_funcs;\n");
out($f,"static zend_op hybrid_halt_op;\n");
out($f,"#endif\n");
}
}
$prolog = $m[1];
out($f,$prolog."if (UNEXPECTED(execute_data == NULL)) {\n");
- out($f,$prolog."\tstatic const void* labels[] = {\n");
+ out($f,$prolog."\tstatic const void * const labels[] = {\n");
gen_labels($f, $spec, ZEND_VM_KIND_GOTO, $prolog."\t\t", $specs);
out($f,$prolog."\t};\n");
out($f,$prolog."\tzend_opcode_handlers = (const void **) labels;\n");
out($f,$prolog."zend_spec_handlers = specs;\n");
out($f,$prolog.$executor_name."_ex(NULL);\n");
} else {
- out($f,$prolog."static const void *labels[] = {\n");
+ out($f,$prolog."static const void * const labels[] = {\n");
gen_labels($f, $spec, ZEND_VM_KIND_CALL, $prolog."\t", $specs, $switch_labels);
out($f,$prolog."};\n");
out($f,$prolog."static const uint32_t specs[] = {\n");
/* }}} */
-const zend_function_entry bcmath_functions[] = {
+static const zend_function_entry bcmath_functions[] = {
PHP_FE(bcadd, arginfo_bcadd)
PHP_FE(bcsub, arginfo_bcsub)
PHP_FE(bcmul, arginfo_bcmul)
/* }}} */
-const zend_function_entry calendar_functions[] = {
+static const zend_function_entry calendar_functions[] = {
PHP_FE(jdtogregorian, arginfo_jdtogregorian)
PHP_FE(gregoriantojd, arginfo_gregoriantojd)
PHP_FE(jdtojulian, arginfo_jdtojulian)
ZEND_END_ARG_INFO()
/* }}} */
-const zend_function_entry com_dotnet_functions[] = {
+static const zend_function_entry com_dotnet_functions[] = {
PHP_FE(variant_set, arginfo_variant_set)
PHP_FE(variant_add, arginfo_variant_add)
PHP_FE(variant_cat, arginfo_variant_cat)
/* {{{ curl_functions[]
*/
-const zend_function_entry curl_functions[] = {
+static const zend_function_entry curl_functions[] = {
PHP_FE(curl_init, arginfo_curl_init)
PHP_FE(curl_copy_handle, arginfo_curl_copy_handle)
PHP_FE(curl_version, arginfo_curl_version)
/* }}} */
/* {{{ Function table */
-const zend_function_entry date_functions[] = {
+static const zend_function_entry date_functions[] = {
PHP_FE(strtotime, arginfo_strtotime)
PHP_FE(date, arginfo_date)
PHP_FE(idate, arginfo_idate)
PHP_FE_END
};
-const zend_function_entry date_funcs_date[] = {
+static const zend_function_entry date_funcs_date[] = {
PHP_ME(DateTime, __construct, arginfo_date_create, ZEND_ACC_CTOR|ZEND_ACC_PUBLIC)
PHP_ME(DateTime, __wakeup, NULL, ZEND_ACC_PUBLIC)
PHP_ME(DateTime, __set_state, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_FE_END
};
-const zend_function_entry date_funcs_immutable[] = {
+static const zend_function_entry date_funcs_immutable[] = {
PHP_ME(DateTimeImmutable, __construct, arginfo_date_create, ZEND_ACC_CTOR|ZEND_ACC_PUBLIC)
PHP_ME(DateTime, __wakeup, NULL, ZEND_ACC_PUBLIC)
PHP_ME(DateTimeImmutable, __set_state, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_FE_END
};
-const zend_function_entry date_funcs_timezone[] = {
+static const zend_function_entry date_funcs_timezone[] = {
PHP_ME(DateTimeZone, __construct, arginfo_timezone_open, ZEND_ACC_CTOR|ZEND_ACC_PUBLIC)
PHP_ME(DateTimeZone, __wakeup, NULL, ZEND_ACC_PUBLIC)
PHP_ME(DateTimeZone, __set_state, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_FE_END
};
-const zend_function_entry date_funcs_interval[] = {
+static const zend_function_entry date_funcs_interval[] = {
PHP_ME(DateInterval, __construct, arginfo_date_interval_construct, ZEND_ACC_CTOR|ZEND_ACC_PUBLIC)
PHP_ME(DateInterval, __wakeup, NULL, ZEND_ACC_PUBLIC)
PHP_ME(DateInterval, __set_state, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
PHP_FE_END
};
-const zend_function_entry date_funcs_period[] = {
+static const zend_function_entry date_funcs_period[] = {
PHP_ME(DatePeriod, __construct, arginfo_date_period_construct, ZEND_ACC_CTOR|ZEND_ACC_PUBLIC)
PHP_ME(DatePeriod, __wakeup, NULL, ZEND_ACC_PUBLIC)
PHP_ME(DatePeriod, __set_state, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
/* {{{ dba_functions[]
*/
-const zend_function_entry dba_functions[] = {
+static const zend_function_entry dba_functions[] = {
PHP_FE(dba_open, arginfo_dba_open)
PHP_FE(dba_popen, arginfo_dba_popen)
PHP_FE(dba_close, arginfo_dba_close)
*
* Every user visible function must have an entry in enchant_functions[].
*/
-zend_function_entry enchant_functions[] = {
+static const zend_function_entry enchant_functions[] = {
PHP_FE(enchant_broker_init, arginfo_enchant_broker_init)
PHP_FE(enchant_broker_free, arginfo_enchant_broker_free)
PHP_FE(enchant_broker_get_error, arginfo_enchant_broker_free)
/* {{{ exif_functions[]
*/
-const zend_function_entry exif_functions[] = {
+static const zend_function_entry exif_functions[] = {
PHP_FE(exif_read_data, arginfo_exif_read_data)
PHP_DEP_FALIAS(read_exif_data, exif_read_data, arginfo_exif_read_data)
PHP_FE(exif_tagname, arginfo_exif_tagname)
/* {{{ finfo_class_functions
*/
-zend_function_entry finfo_class_functions[] = {
+static const zend_function_entry finfo_class_functions[] = {
ZEND_ME_MAPPING(finfo, finfo_open, arginfo_finfo_open, ZEND_ACC_PUBLIC)
ZEND_ME_MAPPING(set_flags, finfo_set_flags,arginfo_finfo_method_set_flags, ZEND_ACC_PUBLIC)
ZEND_ME_MAPPING(file, finfo_file, arginfo_finfo_method_file, ZEND_ACC_PUBLIC)
/* {{{ fileinfo_functions[]
*/
-zend_function_entry fileinfo_functions[] = {
+static const zend_function_entry fileinfo_functions[] = {
PHP_FE(finfo_open, arginfo_finfo_open)
PHP_FE(finfo_close, arginfo_finfo_close)
PHP_FE(finfo_set_flags, arginfo_finfo_set_flags)
/* }}} */
-const zend_function_entry php_ftp_functions[] = {
+static const zend_function_entry php_ftp_functions[] = {
PHP_FE(ftp_connect, arginfo_ftp_connect)
#ifdef HAVE_FTP_SSL
PHP_FE(ftp_ssl_connect, arginfo_ftp_ssl_connect)
/* {{{ gd_functions[]
*/
-const zend_function_entry gd_functions[] = {
+static const zend_function_entry gd_functions[] = {
PHP_FE(gd_info, arginfo_gd_info)
PHP_FE(imagearc, arginfo_imagearc)
PHP_FE(imageellipse, arginfo_imageellipse)
/* {{{ php_gettext_functions[]
*/
-const zend_function_entry php_gettext_functions[] = {
+static const zend_function_entry php_gettext_functions[] = {
PHP_NAMED_FE(textdomain, zif_textdomain, arginfo_textdomain)
PHP_NAMED_FE(gettext, zif_gettext, arginfo_gettext)
/* Alias for gettext() */
/* {{{ gmp_functions[]
*/
-const zend_function_entry gmp_functions[] = {
+static const zend_function_entry gmp_functions[] = {
ZEND_FE(gmp_init, arginfo_gmp_init)
ZEND_FE(gmp_import, arginfo_gmp_import)
ZEND_FE(gmp_export, arginfo_gmp_export)
}
/* }}} */
-static zend_function_entry php_hashcontext_methods[] = {
+static const zend_function_entry php_hashcontext_methods[] = {
PHP_ME(HashContext, __construct, NULL, ZEND_ACC_PRIVATE | ZEND_ACC_CTOR)
PHP_FE_END
};
/* {{{ hash_functions[]
*/
-const zend_function_entry hash_functions[] = {
+static const zend_function_entry hash_functions[] = {
PHP_FE(hash, arginfo_hash)
PHP_FE(hash_file, arginfo_hash_file)
/* {{{ iconv_functions[]
*/
-const zend_function_entry iconv_functions[] = {
+static const zend_function_entry iconv_functions[] = {
PHP_RAW_NAMED_FE(iconv,php_if_iconv, arginfo_iconv)
PHP_FE(iconv_get_encoding, arginfo_iconv_get_encoding)
PHP_FE(iconv_set_encoding, arginfo_iconv_set_encoding)
/* {{{ imap_functions[]
*/
-const zend_function_entry imap_functions[] = {
+static const zend_function_entry imap_functions[] = {
PHP_FE(imap_open, arginfo_imap_open)
PHP_FE(imap_reopen, arginfo_imap_reopen)
PHP_FE(imap_close, arginfo_imap_close)
/* }}} */
/* {{{ extension definition structures */
-const zend_function_entry ibase_functions[] = {
+static const zend_function_entry ibase_functions[] = {
PHP_FE(ibase_connect, arginfo_ibase_connect)
PHP_FE(ibase_pconnect, arginfo_ibase_pconnect)
PHP_FE(ibase_close, arginfo_ibase_close)
* Every 'Collator' class method has an entry in this table
*/
-zend_function_entry Collator_class_functions[] = {
+static const zend_function_entry Collator_class_functions[] = {
PHP_ME( Collator, __construct, collator_1_arg, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR )
ZEND_FENTRY( create, ZEND_FN( collator_create ), collator_1_arg, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
PHP_NAMED_FE( compare, ZEND_FN( collator_compare ), collator_2_args )
ZEND_BEGIN_ARG_INFO_EX(ainfo_se_void, 0, 0, 0)
ZEND_END_ARG_INFO()
-static zend_function_entry IntlIterator_class_functions[] = {
+static const zend_function_entry IntlIterator_class_functions[] = {
PHP_ME(IntlIterator, current, ainfo_se_void, ZEND_ACC_PUBLIC)
PHP_ME(IntlIterator, key, ainfo_se_void, ZEND_ACC_PUBLIC)
PHP_ME(IntlIterator, next, ainfo_se_void, ZEND_ACC_PUBLIC)
}
/* }}} */
-static zend_function_entry php_converter_methods[] = {
+static const zend_function_entry php_converter_methods[] = {
PHP_ME(UConverter, __construct, php_converter_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_CTOR)
/* Encoding selection */
/* {{{ IntlDateFormatter_class_functions
* Every 'IntlDateFormatter' class method has an entry in this table
*/
-static zend_function_entry IntlDateFormatter_class_functions[] = {
+static const zend_function_entry IntlDateFormatter_class_functions[] = {
PHP_ME( IntlDateFormatter, __construct, arginfo_intldateformatter___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR )
ZEND_FENTRY( create, ZEND_FN( datefmt_create ), arginfo_intldateformatter___construct, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
PHP_NAMED_FE( getDateType, ZEND_FN( datefmt_get_datetype ), arginfo_intldateformatter_getdatetype )
/* {{{ NumberFormatter_class_functions
* Every 'NumberFormatter' class method has an entry in this table
*/
-static zend_function_entry NumberFormatter_class_functions[] = {
+static const zend_function_entry NumberFormatter_class_functions[] = {
PHP_ME( NumberFormatter, __construct, arginfo_numberformatter___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR )
ZEND_FENTRY( create, ZEND_FN( numfmt_create ), arginfo_numberformatter___construct, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
PHP_NAMED_FE( format, ZEND_FN( numfmt_format ), arginfo_numberformatter_format )
* Every 'Locale' class method has an entry in this table
*/
-zend_function_entry Locale_class_functions[] = {
+static const zend_function_entry Locale_class_functions[] = {
ZEND_FENTRY( getDefault, zif_locale_get_default , locale_0_args , ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
ZEND_FENTRY( setDefault, zif_locale_set_default , locale_arg_locale , ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
ZEND_FENTRY( getPrimaryLanguage, ZEND_FN( locale_get_primary_language ), locale_arg_locale , ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
/* {{{ MessageFormatter_class_functions
* Every 'MessageFormatter' class method has an entry in this table
*/
-static zend_function_entry MessageFormatter_class_functions[] = {
+static const zend_function_entry MessageFormatter_class_functions[] = {
PHP_ME( MessageFormatter, __construct, arginfo_messageformatter___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR )
ZEND_FENTRY( create, ZEND_FN( msgfmt_create ), arginfo_messageformatter___construct, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
PHP_NAMED_FE( format, ZEND_FN( msgfmt_format ), arginfo_messageformatter_format )
* Every 'Normalizer' class method has an entry in this table
*/
-zend_function_entry Normalizer_class_functions[] = {
+static const zend_function_entry Normalizer_class_functions[] = {
ZEND_FENTRY( normalize, ZEND_FN( normalizer_normalize ), normalizer_args, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
ZEND_FENTRY( isNormalized, ZEND_FN( normalizer_is_normalized ), normalizer_args, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
PHP_FE_END
*
* Every user visible function must have an entry in intl_functions[].
*/
-zend_function_entry intl_functions[] = {
+static const zend_function_entry intl_functions[] = {
/* collator functions */
PHP_FE( collator_create, collator_static_1_arg )
/* {{{ ResourceBundle_class_functions
* Every 'ResourceBundle' class method has an entry in this table
*/
-static zend_function_entry ResourceBundle_class_functions[] = {
+static const zend_function_entry ResourceBundle_class_functions[] = {
PHP_ME( ResourceBundle, __construct, arginfo_resourcebundle___construct, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR )
ZEND_NAMED_ME( create, ZEND_FN( resourcebundle_create ), arginfo_resourcebundle___construct, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC )
ZEND_NAMED_ME( get, ZEND_FN(resourcebundle_get), arginfo_resourcebundle_get, ZEND_ACC_PUBLIC )
* Every 'Spoofchecker' class method has an entry in this table
*/
-zend_function_entry Spoofchecker_class_functions[] = {
+static const zend_function_entry Spoofchecker_class_functions[] = {
PHP_ME(Spoofchecker, __construct, spoofchecker_0_args, ZEND_ACC_PUBLIC|ZEND_ACC_CTOR)
PHP_ME(Spoofchecker, isSuspicious, spoofchecker_is_suspicous, ZEND_ACC_PUBLIC)
PHP_ME(Spoofchecker, areConfusable, spoofchecker_are_confusable, ZEND_ACC_PUBLIC)
/* {{{ TimeZone_class_functions
* Every 'IntlTimeZone' class method has an entry in this table
*/
-static zend_function_entry TimeZone_class_functions[] = {
+static const zend_function_entry TimeZone_class_functions[] = {
PHP_ME(IntlTimeZone, __construct, ainfo_tz_void, ZEND_ACC_PRIVATE)
PHP_ME_MAPPING(createTimeZone, intltz_create_time_zone, ainfo_tz_idarg, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
PHP_ME_MAPPING(fromDateTimeZone, intltz_from_date_time_zone, ainfo_tz_idarg, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
/* {{{ Transliterator_class_functions
* Every 'Transliterator' class method has an entry in this table
*/
-zend_function_entry Transliterator_class_functions[] = {
+static const zend_function_entry Transliterator_class_functions[] = {
PHP_ME( Transliterator, __construct, ainfo_trans_void, ZEND_ACC_PRIVATE | ZEND_ACC_CTOR | ZEND_ACC_FINAL )
PHP_ME_MAPPING( create, transliterator_create, ainfo_trans_create, ZEND_ACC_STATIC |ZEND_ACC_PUBLIC )
PHP_ME_MAPPING( createFromRules,transliterator_create_from_rules, ainfo_trans_create_from_rules, ZEND_ACC_STATIC | ZEND_ACC_PUBLIC )
#undef IC_CHAR_METHOD_CHAR
/* }}} */
-static zend_function_entry intlchar_methods[] = {
+static const zend_function_entry intlchar_methods[] = {
#define IC_ME(mname) PHP_ME(IntlChar, mname, mname##_arginfo, ZEND_ACC_PUBLIC | ZEND_ACC_STATIC)
IC_ME(chr)
IC_ME(ord)
*/
/* {{{ ldap_functions[]
*/
-const zend_function_entry ldap_functions[] = {
+static const zend_function_entry ldap_functions[] = {
PHP_FE(ldap_connect, arginfo_ldap_connect)
PHP_FALIAS(ldap_close, ldap_unbind, arginfo_ldap_resource)
PHP_FE(ldap_bind, arginfo_ldap_bind)
/* }}} */
/* {{{ zend_function_entry mbstring_functions[] */
-const zend_function_entry mbstring_functions[] = {
+static const zend_function_entry mbstring_functions[] = {
PHP_FE(mb_convert_case, arginfo_mb_convert_case)
PHP_FE(mb_strtoupper, arginfo_mb_strtoupper)
PHP_FE(mb_strtolower, arginfo_mb_strtolower)
OnigEncoding code;
} php_mb_regex_enc_name_map_t;
-php_mb_regex_enc_name_map_t enc_name_map[] = {
+static const php_mb_regex_enc_name_map_t enc_name_map[] = {
#ifdef ONIG_ENCODING_EUC_JP
{
"EUC-JP\0EUCJP\0X-EUC-JP\0UJIS\0EUCJP\0EUCJP-WIN\0",
static OnigEncoding _php_mb_regex_name2mbctype(const char *pname)
{
const char *p;
- php_mb_regex_enc_name_map_t *mapping;
+ const php_mb_regex_enc_name_map_t *mapping;
if (pname == NULL || !*pname) {
return ONIG_ENCODING_UNDEF;
/* {{{ php_mb_regex_mbctype2name */
static const char *_php_mb_regex_mbctype2name(OnigEncoding mbctype)
{
- php_mb_regex_enc_name_map_t *mapping;
+ const php_mb_regex_enc_name_map_t *mapping;
for (mapping = enc_name_map; mapping->names != NULL; mapping++) {
if (mapping->code == mbctype) {
/* {{{ odbc_functions[]
*/
-const zend_function_entry odbc_functions[] = {
+static const zend_function_entry odbc_functions[] = {
PHP_FE(odbc_autocommit, arginfo_odbc_autocommit)
PHP_FE(odbc_binmode, arginfo_odbc_binmode)
PHP_FE(odbc_close, arginfo_odbc_close)
static ZEND_FUNCTION(opcache_compile_file);
static ZEND_FUNCTION(opcache_get_configuration);
-static zend_function_entry accel_functions[] = {
+static const zend_function_entry accel_functions[] = {
/* User functions */
ZEND_FE(opcache_reset, arginfo_opcache_none)
ZEND_FE(opcache_invalidate, arginfo_opcache_invalidate)
/* {{{ openssl_functions[]
*/
-const zend_function_entry openssl_functions[] = {
+static const zend_function_entry openssl_functions[] = {
PHP_FE(openssl_get_cert_locations, arginfo_openssl_get_cert_locations)
/* spki functions */
ZEND_END_ARG_INFO()
/* }}} */
-const zend_function_entry pcntl_functions[] = {
+static const zend_function_entry pcntl_functions[] = {
PHP_FE(pcntl_fork, arginfo_pcntl_void)
PHP_FE(pcntl_waitpid, arginfo_pcntl_waitpid)
PHP_FE(pcntl_wait, arginfo_pcntl_wait)
}
/* }}} */
-PDO_API int php_pdo_register_driver(pdo_driver_t *driver) /* {{{ */
+PDO_API int php_pdo_register_driver(const pdo_driver_t *driver) /* {{{ */
{
if (driver->api_version != PDO_DRIVER_API) {
zend_error(E_ERROR, "PDO: driver %s requires PDO API version " ZEND_ULONG_FMT "; this is PDO version %d",
return FAILURE; /* NOTREACHED */
}
- return zend_hash_str_add_ptr(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len, driver) != NULL;
+ return zend_hash_str_add_ptr(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len, (void*)driver) != NULL;
}
/* }}} */
-PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver) /* {{{ */
+PDO_API void php_pdo_unregister_driver(const pdo_driver_t *driver) /* {{{ */
{
if (!zend_hash_str_exists(&module_registry, "pdo", sizeof("pdo") - 1)) {
return;
struct _pdo_dbh_t {
/* driver specific methods */
- struct pdo_dbh_methods *methods;
+ const struct pdo_dbh_methods *methods;
/* driver specific data */
void *driver_data;
};
/* call this in MINIT to register your PDO driver */
-PDO_API int php_pdo_register_driver(pdo_driver_t *driver);
+PDO_API int php_pdo_register_driver(const pdo_driver_t *driver);
/* call this in MSHUTDOWN to unregister your PDO driver */
-PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver);
+PDO_API void php_pdo_unregister_driver(const pdo_driver_t *driver);
/* For the convenience of drivers, this function will parse a data source
* string, of the form "name=value; name2=value2" and populate variables
return 1;
}
-static struct pdo_dbh_methods dblib_methods = {
+static const struct pdo_dbh_methods dblib_methods = {
dblib_handle_closer,
dblib_handle_preparer,
dblib_handle_doer,
return ret;
}
-pdo_driver_t pdo_dblib_driver = {
+const pdo_driver_t pdo_dblib_driver = {
#if PDO_DBLIB_IS_MSSQL
PDO_DRIVER_HEADER(mssql),
#elif defined(PHP_WIN32)
ZEND_DECLARE_MODULE_GLOBALS(dblib)
static PHP_GINIT_FUNCTION(dblib);
-const zend_function_entry pdo_dblib_functions[] = {
+static const zend_function_entry pdo_dblib_functions[] = {
PHP_FE_END
};
int pdo_dblib_msg_handler(DBPROCESS *dbproc, DBINT msgno, int msgstate,
int severity, char *msgtext, char *srvname, char *procname, DBUSMALLINT line);
-extern pdo_driver_t pdo_dblib_driver;
+extern const pdo_driver_t pdo_dblib_driver;
extern struct pdo_stmt_methods dblib_stmt_methods;
typedef struct {
}
/* }}} */
-static struct pdo_dbh_methods firebird_methods = { /* {{{ */
+static const struct pdo_dbh_methods firebird_methods = { /* {{{ */
firebird_handle_closer,
firebird_handle_preparer,
firebird_handle_doer,
/* }}} */
-pdo_driver_t pdo_firebird_driver = { /* {{{ */
+const pdo_driver_t pdo_firebird_driver = { /* {{{ */
PDO_DRIVER_HEADER(firebird),
pdo_firebird_handle_factory
};
#include "php_pdo_firebird.h"
#include "php_pdo_firebird_int.h"
-const zend_function_entry pdo_firebird_functions[] = { /* {{{ */
+static const zend_function_entry pdo_firebird_functions[] = { /* {{{ */
PHP_FE_END
};
/* }}} */
} pdo_firebird_stmt;
-extern pdo_driver_t pdo_firebird_driver;
+extern const pdo_driver_t pdo_firebird_driver;
extern struct pdo_stmt_methods firebird_stmt_methods;
/* }}} */
/* {{{ mysql_methods */
-static struct pdo_dbh_methods mysql_methods = {
+static const struct pdo_dbh_methods mysql_methods = {
mysql_handle_closer,
mysql_handle_preparer,
mysql_handle_doer,
}
/* }}} */
-pdo_driver_t pdo_mysql_driver = {
+const pdo_driver_t pdo_mysql_driver = {
PDO_DRIVER_HEADER(mysql),
pdo_mysql_handle_factory
};
/* }}} */
/* {{{ pdo_mysql_functions[] */
-const zend_function_entry pdo_mysql_functions[] = {
+static const zend_function_entry pdo_mysql_functions[] = {
PHP_FE_END
};
/* }}} */
unsigned max_length:1;
} pdo_mysql_stmt;
-extern pdo_driver_t pdo_mysql_driver;
+extern const pdo_driver_t pdo_mysql_driver;
extern int _pdo_mysql_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line);
#define pdo_mysql_error(s) _pdo_mysql_error(s, NULL, __FILE__, __LINE__)
}
/* }}} */
-static struct pdo_dbh_methods oci_methods = {
+static const struct pdo_dbh_methods oci_methods = {
oci_handle_closer,
oci_handle_preparer,
oci_handle_doer,
}
/* }}} */
-pdo_driver_t pdo_oci_driver = {
+const pdo_driver_t pdo_oci_driver = {
PDO_DRIVER_HEADER(oci),
pdo_oci_handle_factory
};
#endif
/* {{{ pdo_oci_functions[] */
-const zend_function_entry pdo_oci_functions[] = {
+static const zend_function_entry pdo_oci_functions[] = {
PHP_FE_END
};
/* }}} */
} pdo_oci_bound_param;
extern const ub4 PDO_OCI_INIT_MODE;
-extern pdo_driver_t pdo_oci_driver;
+extern const pdo_driver_t pdo_oci_driver;
extern OCIEnv *pdo_oci_Env;
ub4 _oci_error(OCIError *err, pdo_dbh_t *dbh, pdo_stmt_t *stmt, char *what, sword status, int isinit, const char *file, int line);
return 0;
}
-static struct pdo_dbh_methods odbc_methods = {
+static const struct pdo_dbh_methods odbc_methods = {
odbc_handle_closer,
odbc_handle_preparer,
odbc_handle_doer,
}
/* }}} */
-pdo_driver_t pdo_odbc_driver = {
+const pdo_driver_t pdo_odbc_driver = {
PDO_DRIVER_HEADER(odbc),
pdo_odbc_handle_factory
};
#include "php_pdo_odbc_int.h"
/* {{{ pdo_odbc_functions[] */
-const zend_function_entry pdo_odbc_functions[] = {
+static const zend_function_entry pdo_odbc_functions[] = {
PHP_FE_END
};
/* }}} */
unsigned _spare:31;
} pdo_odbc_param;
-extern pdo_driver_t pdo_odbc_driver;
+extern const pdo_driver_t pdo_odbc_driver;
extern struct pdo_stmt_methods odbc_stmt_methods;
void pdo_odbc_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, PDO_ODBC_HSTMT statement, char *what, const char *file, int line);
#endif
/* {{{ pdo_pgsql_functions[] */
-const zend_function_entry pdo_pgsql_functions[] = {
+static const zend_function_entry pdo_pgsql_functions[] = {
PHP_FE_END
};
/* }}} */
}
}
-static struct pdo_dbh_methods pgsql_methods = {
+static const struct pdo_dbh_methods pgsql_methods = {
pgsql_handle_closer,
pgsql_handle_preparer,
pgsql_handle_doer,
}
/* }}} */
-pdo_driver_t pdo_pgsql_driver = {
+const pdo_driver_t pdo_pgsql_driver = {
PDO_DRIVER_HEADER(pgsql),
pdo_pgsql_handle_factory
};
Oid oid;
} pdo_pgsql_bound_param;
-extern pdo_driver_t pdo_pgsql_driver;
+extern const pdo_driver_t pdo_pgsql_driver;
extern int _pdo_pgsql_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, int errcode, const char *sqlstate, const char *msg, const char *file, int line);
#define pdo_pgsql_error(d,e,z) _pdo_pgsql_error(d, NULL, e, z, NULL, __FILE__, __LINE__)
#include "zend_exceptions.h"
/* {{{ pdo_sqlite_functions[] */
-const zend_function_entry pdo_sqlite_functions[] = {
+static const zend_function_entry pdo_sqlite_functions[] = {
PHP_FE_END
};
/* }}} */
unsigned done:1;
} pdo_sqlite_stmt;
-extern pdo_driver_t pdo_sqlite_driver;
+extern const pdo_driver_t pdo_sqlite_driver;
extern int _pdo_sqlite_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *file, int line);
#define pdo_sqlite_error(s) _pdo_sqlite_error(s, NULL, __FILE__, __LINE__)
}
}
-static struct pdo_dbh_methods sqlite_methods = {
+static const struct pdo_dbh_methods sqlite_methods = {
sqlite_handle_closer,
sqlite_handle_preparer,
sqlite_handle_doer,
}
/* }}} */
-pdo_driver_t pdo_sqlite_driver = {
+const pdo_driver_t pdo_sqlite_driver = {
PDO_DRIVER_HEADER(sqlite),
pdo_sqlite_handle_factory
};
/* {{{ pgsql_functions[]
*/
-const zend_function_entry pgsql_functions[] = {
+static const zend_function_entry pgsql_functions[] = {
/* connection functions */
PHP_FE(pg_connect, arginfo_pg_connect)
PHP_FE(pg_pconnect, arginfo_pg_pconnect)
*
* Every user visible function must have an entry in phar_functions[].
*/
-zend_function_entry phar_functions[] = {
+static const zend_function_entry phar_functions[] = {
PHP_FE_END
};
/* }}}*/
ZEND_END_ARG_INFO()
-zend_function_entry php_archive_methods[] = {
+static const zend_function_entry php_archive_methods[] = {
PHP_ME(Phar, __construct, arginfo_phar___construct, ZEND_ACC_PUBLIC)
PHP_ME(Phar, __destruct, arginfo_phar__void, ZEND_ACC_PUBLIC)
PHP_ME(Phar, addEmptyDir, arginfo_phar_emptydir, ZEND_ACC_PUBLIC)
ZEND_ARG_INFO(0, fileformat)
ZEND_END_ARG_INFO()
-zend_function_entry php_data_methods[] = {
+static const zend_function_entry php_data_methods[] = {
PHP_ME(Phar, __construct, arginfo_data___construct, ZEND_ACC_PUBLIC)
PHP_ME(Phar, __destruct, arginfo_phar__void, ZEND_ACC_PUBLIC)
PHP_ME(Phar, addEmptyDir, arginfo_phar_emptydir, ZEND_ACC_PUBLIC)
ZEND_ARG_INFO(0, perms)
ZEND_END_ARG_INFO()
-zend_function_entry php_entry_methods[] = {
+static const zend_function_entry php_entry_methods[] = {
PHP_ME(PharFileInfo, __construct, arginfo_entry___construct, ZEND_ACC_PUBLIC)
PHP_ME(PharFileInfo, __destruct, arginfo_phar__void, ZEND_ACC_PUBLIC)
PHP_ME(PharFileInfo, chmod, arginfo_entry_chmod, ZEND_ACC_PUBLIC)
PHP_FE_END
};
-zend_function_entry phar_exception_methods[] = {
+static const zend_function_entry phar_exception_methods[] = {
PHP_FE_END
};
/* }}} */
/* {{{ posix_functions[]
*/
-const zend_function_entry posix_functions[] = {
+static const zend_function_entry posix_functions[] = {
/* POSIX.1, 3.3 */
PHP_FE(posix_kill, arginfo_posix_kill)
/* {{{ posix_addlimit
*/
-static int posix_addlimit(int limit, char *name, zval *return_value) {
+static int posix_addlimit(int limit, const char *name, zval *return_value) {
int result;
struct rlimit rl;
char hard[80];
/* {{{ limits[]
*/
-struct limitlist {
+static const struct limitlist {
int limit;
- char *name;
+ const char *name;
} limits[] = {
#ifdef RLIMIT_CORE
{ RLIMIT_CORE, "core" },
Get system resource consumption limits (This is not a POSIX function, but a BSDism and a SVR4ism. We compile conditionally) */
PHP_FUNCTION(posix_getrlimit)
{
- struct limitlist *l = NULL;
+ const struct limitlist *l = NULL;
PHP_POSIX_NO_ARGS;
};
/* }}} */
-const zend_function_entry reflection_ext_functions[] = { /* {{{ */
+static const zend_function_entry reflection_ext_functions[] = { /* {{{ */
PHP_FE_END
}; /* }}} */
/* {{{ shmop_functions[]
*/
-const zend_function_entry shmop_functions[] = {
+static const zend_function_entry shmop_functions[] = {
PHP_FE(shmop_open, arginfo_shmop_open)
PHP_FE(shmop_read, arginfo_shmop_read)
PHP_FE(shmop_close, arginfo_shmop_close)
ZEND_END_ARG_INFO()
/* }}} */
-const zend_function_entry simplexml_functions[] = { /* {{{ */
+static const zend_function_entry simplexml_functions[] = { /* {{{ */
PHP_FE(simplexml_load_file, arginfo_simplexml_load_file)
PHP_FE(simplexml_load_string, arginfo_simplexml_load_string)
PHP_FE(simplexml_import_dom, arginfo_simplexml_import_dom)
/* {{{ %EXTNAME%_functions[]
*/
-const zend_function_entry %EXTNAME%_functions[] = {
+static const zend_function_entry %EXTNAME%_functions[] = {
PHP_FE(%EXTNAME%_test1, arginfo_%EXTNAME%_test1)
PHP_FE(%EXTNAME%_test2, arginfo_%EXTNAME%_test2)
PHP_FE_END
/* {{{ snmp_functions[]
*/
-const zend_function_entry snmp_functions[] = {
+static const zend_function_entry snmp_functions[] = {
PHP_FE(snmpget, arginfo_snmpget)
PHP_FE(snmpgetnext, arginfo_snmpgetnext)
PHP_FE(snmpwalk, arginfo_snmpwalk)
/* }}} */
/* {{{ php_snmp_class_methods[] */
-static zend_function_entry php_snmp_class_methods[] = {
+static const zend_function_entry php_snmp_class_methods[] = {
PHP_ME(snmp, __construct, arginfo_snmp_create, ZEND_ACC_PUBLIC)
PHP_ME(snmp, close, arginfo_snmp_void, ZEND_ACC_PUBLIC)
PHP_ME(snmp, setSecurity, arginfo_snmp_setSecurity, ZEND_ACC_PUBLIC)
} \
}
-encode defaultEncoding[] = {
+const encode defaultEncoding[] = {
{{UNKNOWN_TYPE, NULL, NULL, NULL, NULL}, guess_zval_convert, guess_xml_convert},
{{IS_NULL, "nil", XSI_NAMESPACE, NULL, NULL}, to_zval_null, to_xml_null},
void delete_encoder(zval *zv);
void delete_encoder_persistent(zval *zv);
-extern encode defaultEncoding[];
+extern const encode defaultEncoding[];
extern int numDefaultEncodings;
#endif
sdlBindingPtr *bindings;
sdlTypePtr *types;
encodePtr *encoders;
- encodePtr enc;
+ const encode *enc;
int f;
struct stat st;
i = num_encoders;
enc = defaultEncoding;
while (enc->details.type != END_KNOWN_TYPES) {
- encoders[++i] = enc++;
+ encoders[++i] = (encodePtr)enc++;
}
i = 1;
int type_num = 1;
int encoder_num = 1;
int f;
- encodePtr enc;
+ const encode *enc;
HashTable tmp_types;
HashTable tmp_encoders;
HashTable tmp_bindings;
static void php_soap_prepare_globals()
{
int i;
- encodePtr enc;
+ const encode* enc;
zend_hash_init(&defEnc, 0, NULL, NULL, 1);
zend_hash_init(&defEncIndex, 0, NULL, NULL, 1);
if (defaultEncoding[i].details.ns != NULL) {
char *ns_type;
spprintf(&ns_type, 0, "%s:%s", defaultEncoding[i].details.ns, defaultEncoding[i].details.type_str);
- zend_hash_str_add_ptr(&defEnc, ns_type, strlen(ns_type), enc);
+ zend_hash_str_add_ptr(&defEnc, ns_type, strlen(ns_type), (void*)enc);
efree(ns_type);
} else {
- zend_hash_str_add_ptr(&defEnc, defaultEncoding[i].details.type_str, strlen(defaultEncoding[i].details.type_str), enc);
+ zend_hash_str_add_ptr(&defEnc, defaultEncoding[i].details.type_str, strlen(defaultEncoding[i].details.type_str), (void*)enc);
}
}
/* Index everything by number */
if (!zend_hash_index_exists(&defEncIndex, defaultEncoding[i].details.type)) {
- zend_hash_index_update_ptr(&defEncIndex, defaultEncoding[i].details.type, enc);
+ zend_hash_index_update_ptr(&defEncIndex, defaultEncoding[i].details.type, (void*)enc);
}
i++;
} while (defaultEncoding[i].details.type != END_KNOWN_TYPES);
/* {{{ sockets_functions[]
*/
-const zend_function_entry sockets_functions[] = {
+static const zend_function_entry sockets_functions[] = {
PHP_FE(socket_select, arginfo_socket_select)
PHP_FE(socket_create, arginfo_socket_create)
PHP_FE(socket_create_listen, arginfo_socket_create_listen)
# define crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_MIN crypto_pwhash_scryptsalsa208sha256_MEMLIMIT_INTERACTIVE
#endif
-const zend_function_entry sodium_functions[] = {
+static const zend_function_entry sodium_functions[] = {
PHP_FE(sodium_crypto_aead_aes256gcm_is_available, AI_None)
#ifdef HAVE_AESGCM
PHP_FE(sodium_crypto_aead_aes256gcm_decrypt, AI_StringAndADAndNonceAndKey)
/* {{{ spl_functions
*/
-const zend_function_entry spl_functions[] = {
+static const zend_function_entry spl_functions[] = {
PHP_FE(spl_classes, arginfo_spl_classes)
PHP_FE(spl_autoload, arginfo_spl_autoload)
PHP_FE(spl_autoload_extensions, arginfo_spl_autoload_extensions)
ZEND_BEGIN_ARG_INFO(arginfo_splfixedarray_void, 0)
ZEND_END_ARG_INFO()
-static zend_function_entry spl_funcs_SplFixedArray[] = { /* {{{ */
+static const zend_function_entry spl_funcs_SplFixedArray[] = { /* {{{ */
SPL_ME(SplFixedArray, __construct, arginfo_splfixedarray_construct,ZEND_ACC_PUBLIC)
SPL_ME(SplFixedArray, __wakeup, arginfo_splfixedarray_void, ZEND_ACC_PUBLIC)
SPL_ME(SplFixedArray, count, arginfo_splfixedarray_void, ZEND_ACC_PUBLIC)
ZEND_BEGIN_ARG_INFO(arginfo_recursive_it_void, 0)
ZEND_END_ARG_INFO()
-const zend_function_entry spl_funcs_RecursiveIterator[] = {
+static const zend_function_entry spl_funcs_RecursiveIterator[] = {
SPL_ABSTRACT_ME(RecursiveIterator, hasChildren, arginfo_recursive_it_void)
SPL_ABSTRACT_ME(RecursiveIterator, getChildren, arginfo_recursive_it_void)
PHP_FE_END
/* }}} */
/* {{{ php_sqlite3_class_methods */
-static zend_function_entry php_sqlite3_class_methods[] = {
+static const zend_function_entry php_sqlite3_class_methods[] = {
PHP_ME(sqlite3, open, arginfo_sqlite3_open, ZEND_ACC_PUBLIC)
PHP_ME(sqlite3, close, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
PHP_ME(sqlite3, exec, arginfo_sqlite3_query, ZEND_ACC_PUBLIC)
/* }}} */
/* {{{ php_sqlite3_stmt_class_methods */
-static zend_function_entry php_sqlite3_stmt_class_methods[] = {
+static const zend_function_entry php_sqlite3_stmt_class_methods[] = {
PHP_ME(sqlite3stmt, paramCount, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
PHP_ME(sqlite3stmt, close, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
PHP_ME(sqlite3stmt, reset, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
/* }}} */
/* {{{ php_sqlite3_result_class_methods */
-static zend_function_entry php_sqlite3_result_class_methods[] = {
+static const zend_function_entry php_sqlite3_result_class_methods[] = {
PHP_ME(sqlite3result, numColumns, arginfo_sqlite3_void, ZEND_ACC_PUBLIC)
PHP_ME(sqlite3result, columnName, arginfo_sqlite3result_columnname, ZEND_ACC_PUBLIC)
PHP_ME(sqlite3result, columnType, arginfo_sqlite3result_columntype, ZEND_ACC_PUBLIC)
/* }}} */
/* }}} */
-const zend_function_entry basic_functions[] = { /* {{{ */
+static const zend_function_entry basic_functions[] = { /* {{{ */
PHP_FE(constant, arginfo_constant)
PHP_FE(bin2hex, arginfo_bin2hex)
PHP_FE(hex2bin, arginfo_hex2bin)
#define _PASSWORD_EFMT1 '_'
-static u_char IP[64] = {
+static const u_char IP[64] = {
58, 50, 42, 34, 26, 18, 10, 2, 60, 52, 44, 36, 28, 20, 12, 4,
62, 54, 46, 38, 30, 22, 14, 6, 64, 56, 48, 40, 32, 24, 16, 8,
57, 49, 41, 33, 25, 17, 9, 1, 59, 51, 43, 35, 27, 19, 11, 3,
61, 53, 45, 37, 29, 21, 13, 5, 63, 55, 47, 39, 31, 23, 15, 7
};
-static u_char key_perm[56] = {
+static const u_char key_perm[56] = {
57, 49, 41, 33, 25, 17, 9, 1, 58, 50, 42, 34, 26, 18,
10, 2, 59, 51, 43, 35, 27, 19, 11, 3, 60, 52, 44, 36,
63, 55, 47, 39, 31, 23, 15, 7, 62, 54, 46, 38, 30, 22,
14, 6, 61, 53, 45, 37, 29, 21, 13, 5, 28, 20, 12, 4
};
-static u_char key_shifts[16] = {
+static const u_char key_shifts[16] = {
1, 1, 2, 2, 2, 2, 2, 2, 1, 2, 2, 2, 2, 2, 2, 1
};
-static u_char comp_perm[48] = {
+static const u_char comp_perm[48] = {
14, 17, 11, 24, 1, 5, 3, 28, 15, 6, 21, 10,
23, 19, 12, 4, 26, 8, 16, 7, 27, 20, 13, 2,
41, 52, 31, 37, 47, 55, 30, 40, 51, 45, 33, 48,
* No E box is used, as it's replaced by some ANDs, shifts, and ORs.
*/
-static u_char sbox[8][64] = {
+static const u_char sbox[8][64] = {
{
14, 4, 13, 1, 2, 15, 11, 8, 3, 10, 6, 12, 5, 9, 0, 7,
0, 15, 7, 4, 14, 2, 13, 1, 10, 6, 12, 11, 9, 5, 3, 8,
}
};
-static u_char pbox[32] = {
+static const u_char pbox[32] = {
16, 7, 20, 21, 29, 12, 28, 17, 1, 15, 23, 26, 5, 18, 31, 10,
2, 8, 24, 14, 32, 27, 3, 9, 19, 13, 30, 6, 22, 11, 4, 25
};
-static uint32_t bits32[32] =
+static const uint32_t bits32[32] =
{
0x80000000, 0x40000000, 0x20000000, 0x10000000,
0x08000000, 0x04000000, 0x02000000, 0x01000000,
0x00000008, 0x00000004, 0x00000002, 0x00000001
};
-static u_char bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
+static const u_char bits8[8] = { 0x80, 0x40, 0x20, 0x10, 0x08, 0x04, 0x02, 0x01 };
-static unsigned char ascii64[] =
+static const unsigned char ascii64[] =
"./0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";
/* 0000000000111111111122222222223333333333444444444455555555556666 */
/* 0123456789012345678901234567890123456789012345678901234567890123 */
{
int i, j, b, k, inbit, obit;
uint32_t *p, *il, *ir, *fl, *fr;
- uint32_t *bits28, *bits24;
+ const uint32_t *bits28, *bits24;
u_char inv_key_perm[64];
u_char inv_comp_perm[56];
u_char init_perm[64], final_perm[64];
#define crypt _crypt_extended
-static struct {
- char *hash;
- char *pw;
+static const struct {
+ const char *hash;
+ const char *pw;
} tests[] = {
/* "new"-style */
{"_J9..CCCCXBrJUJV154M", "U*U*U*U*"},
static void SHA1Encode(unsigned char *, uint32_t *, unsigned int);
static void SHA1Decode(uint32_t *, const unsigned char *, unsigned int);
-static unsigned char PADDING[64] =
+static const unsigned char PADDING[64] =
{
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
*
* Every user visible function must have an entry in sysvmsg_functions[].
*/
-const zend_function_entry sysvmsg_functions[] = {
+static const zend_function_entry sysvmsg_functions[] = {
PHP_FE(msg_get_queue, arginfo_msg_get_queue)
PHP_FE(msg_send, arginfo_msg_send)
PHP_FE(msg_receive, arginfo_msg_receive)
/* {{{ sysvsem_functions[]
*/
-const zend_function_entry sysvsem_functions[] = {
+static const zend_function_entry sysvsem_functions[] = {
PHP_FE(sem_get, arginfo_sem_get)
PHP_FE(sem_acquire, arginfo_sem_acquire)
PHP_FE(sem_release, arginfo_sem_release)
/* {{{ sysvshm_functions[]
*/
-const zend_function_entry sysvshm_functions[] = {
+static const zend_function_entry sysvshm_functions[] = {
PHP_FE(shm_attach, arginfo_shm_attach)
PHP_FE(shm_remove, arginfo_shm_detach)
PHP_FE(shm_detach, arginfo_shm_remove)
*
* Every user visible function must have an entry in tokenizer_functions[].
*/
-const zend_function_entry tokenizer_functions[] = {
+static const zend_function_entry tokenizer_functions[] = {
PHP_FE(token_get_all, arginfo_token_get_all)
PHP_FE(token_name, arginfo_token_name)
PHP_FE_END
/* {{{ wddx_functions[]
*/
-const zend_function_entry wddx_functions[] = {
+static const zend_function_entry wddx_functions[] = {
PHP_FE(wddx_serialize_value, arginfo_wddx_serialize_value)
PHP_FE(wddx_serialize_vars, arginfo_wddx_serialize_vars)
PHP_FE(wddx_packet_start, arginfo_wddx_serialize_start)
return ret;
}
-static xmlSAXHandler
+static const xmlSAXHandler
php_xml_compat_handlers = {
NULL, /* internalSubset */
NULL, /* isStandalone */
ZEND_ARG_INFO(0, option)
ZEND_END_ARG_INFO()
-const zend_function_entry xml_functions[] = {
+static const zend_function_entry xml_functions[] = {
PHP_FE(xml_parser_create, arginfo_xml_parser_create)
PHP_FE(xml_parser_create_ns, arginfo_xml_parser_create_ns)
PHP_FE(xml_set_object, arginfo_xml_set_object)
ZEND_END_ARG_INFO()
/* }}} */
-const zend_function_entry xmlrpc_functions[] = {
+static const zend_function_entry xmlrpc_functions[] = {
PHP_FE(xmlrpc_encode, arginfo_xmlrpc_encode)
PHP_FE(xmlrpc_decode, arginfo_xmlrpc_decode)
PHP_FE(xmlrpc_decode_request, arginfo_xmlrpc_decode_request)
}
/* }}} */
-static zend_function_entry zend_test_trait_methods[] = {
+static const zend_function_entry zend_test_trait_methods[] = {
ZEND_ME(_ZendTestTrait, testMethod, NULL, ZEND_ACC_PUBLIC)
ZEND_FE_END
};
php_info_print_table_end();
}
-const zend_function_entry zend_test_functions[] = {
+static const zend_function_entry zend_test_functions[] = {
ZEND_FE(zend_test_array_return, arginfo_zend_test_array_return)
ZEND_FE(zend_test_nullable_array_return, arginfo_zend_test_nullable_array_return)
ZEND_FE(zend_create_unterminated_string, NULL)
const char *str;
} http_response_status_code_pair;
-static http_response_status_code_pair http_status_map[] = {
+static const http_response_status_code_pair http_status_map[] = {
{ 100, "Continue" },
{ 101, "Switching Protocols" },
{ 200, "OK" },
@EXT_INCLUDE_CODE@
-static zend_module_entry *php_builtin_extensions[] = {
+static zend_module_entry * const php_builtin_extensions[] = {
@EXT_MODULE_PTRS@
};
/* {{{ php_builtin_extensions[]
*/
-static zend_module_entry *php_builtin_extensions[] = {
+static zend_module_entry * const php_builtin_extensions[] = {
phpext_standard_ptr
#if HAVE_BCMATH
,phpext_bcmath_ptr
/* {{{ php_register_extensions
*/
-int php_register_extensions(zend_module_entry **ptr, int count)
+int php_register_extensions(zend_module_entry * const * ptr, int count)
{
- zend_module_entry **end = ptr + count;
+ zend_module_entry * const * end = ptr + count;
while (ptr < end) {
if (*ptr) {
PHPAPI void php_module_shutdown_for_exec(void);
PHPAPI int php_module_shutdown_wrapper(sapi_module_struct *sapi_globals);
-PHPAPI int php_register_extensions(zend_module_entry **ptr, int count);
+PHPAPI int php_register_extensions(zend_module_entry * const * ptr, int count);
PHPAPI int php_execute_script(zend_file_handle *primary_file);
PHPAPI int php_execute_simple_script(zend_file_handle *primary_file, zval *ret);
ZEND_BEGIN_ARG_INFO(arginfo_no_args, 0)
ZEND_END_ARG_INFO()
-const zend_function_entry cgi_functions[] = {
+static const zend_function_entry cgi_functions[] = {
PHP_FE(apache_child_terminate, arginfo_no_args)
PHP_FE(apache_request_headers, arginfo_no_args)
PHP_FE(apache_response_headers, arginfo_no_args)
PHP_MINFO_FUNCTION(litespeed);
-zend_function_entry litespeed_functions[] = {
+static const zend_function_entry litespeed_functions[] = {
PHP_FE(litespeed_request_headers, arginfo_litespeed__void)
PHP_FE(litespeed_response_headers, arginfo_litespeed__void)
PHP_FE(apache_get_modules, arginfo_litespeed__void)
ZEND_ARG_INFO(0, options)
ZEND_END_ARG_INFO()
-zend_function_entry phpdbg_user_functions[] = {
+static const zend_function_entry phpdbg_user_functions[] = {
PHP_FE(phpdbg_clear, phpdbg_clear_arginfo)
PHP_FE(phpdbg_break_next, phpdbg_break_next_arginfo)
PHP_FE(phpdbg_break_file, phpdbg_break_file_arginfo)
projects / php / commitdiff