PHP NEWS
|||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||
?? ??? 20??, PHP 5.3.0
+- Improved memory usage by movig constants to read only memory. (Dmitry,Pierre)
- Improved ext/soap to support element names in context of XMLShema's <any>.
(Dmitry)
- Improved ext/openssl (Dmitry)
HashTable default_static_members;
HashTable *static_members;
HashTable constants_table;
- struct _zend_function_entry *builtin_functions;
+ const struct _zend_function_entry *builtin_functions;
union _zend_function *constructor;
union _zend_function *destructor;
}
-ZEND_API int add_assoc_function(zval *arg, char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS))
+ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS))
{
zend_error(E_WARNING, "add_assoc_function() is no longer supported");
return FAILURE;
}
-ZEND_API int add_assoc_long_ex(zval *arg, char *key, uint key_len, long n)
+ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n)
{
zval *tmp;
return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
}
-ZEND_API int add_assoc_null_ex(zval *arg, char *key, uint key_len)
+ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len)
{
zval *tmp;
return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
}
-ZEND_API int add_assoc_bool_ex(zval *arg, char *key, uint key_len, int b)
+ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b)
{
zval *tmp;
return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
}
-ZEND_API int add_assoc_resource_ex(zval *arg, char *key, uint key_len, int r)
+ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, int r)
{
zval *tmp;
}
-ZEND_API int add_assoc_double_ex(zval *arg, char *key, uint key_len, double d)
+ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d)
{
zval *tmp;
}
-ZEND_API int add_assoc_string_ex(zval *arg, char *key, uint key_len, char *str, int duplicate)
+ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate)
{
zval *tmp;
}
-ZEND_API int add_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, int duplicate)
+ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate)
{
zval *tmp;
return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
}
-ZEND_API int add_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value)
+ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value)
{
return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &value, sizeof(zval *), NULL);
}
}
-ZEND_API int add_index_string(zval *arg, ulong index, char *str, int duplicate)
+ZEND_API int add_index_string(zval *arg, ulong index, const char *str, int duplicate)
{
zval *tmp;
}
-ZEND_API int add_index_stringl(zval *arg, ulong index, char *str, uint length, int duplicate)
+ZEND_API int add_index_stringl(zval *arg, ulong index, const char *str, uint length, int duplicate)
{
zval *tmp;
}
-ZEND_API int add_next_index_string(zval *arg, char *str, int duplicate)
+ZEND_API int add_next_index_string(zval *arg, const char *str, int duplicate)
{
zval *tmp;
}
-ZEND_API int add_next_index_stringl(zval *arg, char *str, uint length, int duplicate)
+ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length, int duplicate)
{
zval *tmp;
}
-ZEND_API int add_get_assoc_string_ex(zval *arg, char *key, uint key_len, char *str, void **dest, int duplicate)
+ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate)
{
zval *tmp;
}
-ZEND_API int add_get_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, void **dest, int duplicate)
+ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, void **dest, int duplicate)
{
zval *tmp;
}
-ZEND_API int add_get_index_string(zval *arg, ulong index, char *str, void **dest, int duplicate)
+ZEND_API int add_get_index_string(zval *arg, ulong index, const char *str, void **dest, int duplicate)
{
zval *tmp;
}
-ZEND_API int add_get_index_stringl(zval *arg, ulong index, char *str, uint length, void **dest, int duplicate)
+ZEND_API int add_get_index_stringl(zval *arg, ulong index, const char *str, uint length, void **dest, int duplicate)
{
zval *tmp;
/* Check module dependencies */
if (module->deps) {
- zend_module_dep *dep = module->deps;
+ const zend_module_dep *dep = module->deps;
while (dep->name) {
if (dep->type == MODULE_DEP_REQUIRED) {
try_again:
m = (zend_module_entry*)(*b1)->pData;
if (!m->module_started && m->deps) {
- zend_module_dep *dep = m->deps;
+ const zend_module_dep *dep = m->deps;
while (dep->name) {
if (dep->type == MODULE_DEP_REQUIRED || dep->type == MODULE_DEP_OPTIONAL) {
b2 = b1 + 1;
/* Check module dependencies */
if (module->deps) {
- zend_module_dep *dep = module->deps;
+ const zend_module_dep *dep = module->deps;
while (dep->name) {
if (dep->type == MODULE_DEP_CONFLICTS) {
}
/* registers all functions in *library_functions in the function hash */
-ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entry *functions, HashTable *function_table, int type TSRMLS_DC)
+ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_function_entry *functions, HashTable *function_table, int type TSRMLS_DC)
{
- zend_function_entry *ptr = functions;
+ const zend_function_entry *ptr = functions;
zend_function function, *reg_function;
zend_internal_function *internal_function = (zend_internal_function *)&function;
int count=0, unload=0;
while (ptr->fname) {
internal_function->handler = ptr->handler;
- internal_function->function_name = ptr->fname;
+ internal_function->function_name = (char*)ptr->fname;
internal_function->scope = scope;
internal_function->prototype = NULL;
if (ptr->arg_info) {
- internal_function->arg_info = ptr->arg_info+1;
+ internal_function->arg_info = (zend_arg_info*)ptr->arg_info+1;
internal_function->num_args = ptr->num_args;
/* Currently you cannot denote that the function can accept less arguments than num_args */
if (ptr->arg_info[0].required_num_args == -1) {
/* count=-1 means erase all functions, otherwise,
* erase the first count functions
*/
-ZEND_API void zend_unregister_functions(zend_function_entry *functions, int count, HashTable *function_table TSRMLS_DC)
+ZEND_API void zend_unregister_functions(const zend_function_entry *functions, int count, HashTable *function_table TSRMLS_DC)
{
- zend_function_entry *ptr = functions;
+ const zend_function_entry *ptr = functions;
int i=0;
HashTable *target_function_table = function_table;
return retval;
}
-static zend_function_entry disabled_class_new[] = {
+static const zend_function_entry disabled_class_new[] = {
{ NULL, NULL, NULL }
};
}
-ZEND_API char *zend_get_module_version(char *module_name)
+ZEND_API const char *zend_get_module_version(const char *module_name)
{
char *lname;
int name_len = strlen(module_name);
BEGIN_EXTERN_C()
typedef struct _zend_function_entry {
- char *fname;
+ const char *fname;
void (*handler)(INTERNAL_FUNCTION_PARAMETERS);
- struct _zend_arg_info *arg_info;
+ const struct _zend_arg_info *arg_info;
zend_uint num_args;
zend_uint flags;
} zend_function_entry;
#define ZEND_ARG_OBJ_INFO(pass_by_ref, name, classname, allow_null) { #name, sizeof(#name)-1, #classname, sizeof(#classname)-1, 0, allow_null, pass_by_ref, 0, 0 },
#define ZEND_ARG_ARRAY_INFO(pass_by_ref, name, allow_null) { #name, sizeof(#name)-1, NULL, 0, 1, allow_null, pass_by_ref, 0, 0 },
#define ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, return_reference, required_num_args) \
- zend_arg_info name[] = { \
+ const zend_arg_info name[] = { \
{ NULL, 0, NULL, 0, 0, 0, pass_rest_by_reference, return_reference, required_num_args },
#define ZEND_BEGIN_ARG_INFO(name, pass_rest_by_reference) \
ZEND_BEGIN_ARG_INFO_EX(name, pass_rest_by_reference, ZEND_RETURN_VALUE, -1)
/* End of parameter parsing API -- andrei */
-ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entry *functions, HashTable *function_table, int type TSRMLS_DC);
-ZEND_API void zend_unregister_functions(zend_function_entry *functions, int count, HashTable *function_table TSRMLS_DC);
+ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_function_entry *functions, HashTable *function_table, int type TSRMLS_DC);
+ZEND_API void zend_unregister_functions(const zend_function_entry *functions, int count, HashTable *function_table TSRMLS_DC);
ZEND_API int zend_startup_module(zend_module_entry *module_entry);
ZEND_API zend_module_entry* zend_register_internal_module(zend_module_entry *module_entry TSRMLS_DC);
ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module TSRMLS_DC);
ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, char **callable_name, int *callable_name_len, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zval ***zobj_ptr_ptr TSRMLS_DC);
ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, char **callable_name);
ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC);
-ZEND_API char *zend_get_module_version(char *module_name);
+ZEND_API const char *zend_get_module_version(const char *module_name);
ZEND_API int zend_get_module_started(char *module_name);
ZEND_API int zend_declare_property(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type TSRMLS_DC);
ZEND_API int zend_declare_property_ex(zend_class_entry *ce, char *name, int name_length, zval *property, int access_type, char *doc_comment, int doc_comment_len TSRMLS_DC);
ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destroy_ht TSRMLS_DC);
/* no longer supported */
-ZEND_API int add_assoc_function(zval *arg, char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
+ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)(INTERNAL_FUNCTION_PARAMETERS));
-ZEND_API int add_assoc_long_ex(zval *arg, char *key, uint key_len, long n);
-ZEND_API int add_assoc_null_ex(zval *arg, char *key, uint key_len);
-ZEND_API int add_assoc_bool_ex(zval *arg, char *key, uint key_len, int b);
-ZEND_API int add_assoc_resource_ex(zval *arg, char *key, uint key_len, int r);
-ZEND_API int add_assoc_double_ex(zval *arg, char *key, uint key_len, double d);
-ZEND_API int add_assoc_string_ex(zval *arg, char *key, uint key_len, char *str, int duplicate);
-ZEND_API int add_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, int duplicate);
-ZEND_API int add_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value);
+ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n);
+ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len);
+ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b);
+ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, int r);
+ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d);
+ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate);
+ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate);
+ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key)+1, __n)
#define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
ZEND_API int add_index_bool(zval *arg, ulong idx, int b);
ZEND_API int add_index_resource(zval *arg, ulong idx, int r);
ZEND_API int add_index_double(zval *arg, ulong idx, double d);
-ZEND_API int add_index_string(zval *arg, ulong idx, char *str, int duplicate);
-ZEND_API int add_index_stringl(zval *arg, ulong idx, char *str, uint length, int duplicate);
+ZEND_API int add_index_string(zval *arg, ulong idx, const char *str, int duplicate);
+ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length, int duplicate);
ZEND_API int add_index_zval(zval *arg, ulong index, zval *value);
ZEND_API int add_next_index_long(zval *arg, long n);
ZEND_API int add_next_index_bool(zval *arg, int b);
ZEND_API int add_next_index_resource(zval *arg, int r);
ZEND_API int add_next_index_double(zval *arg, double d);
-ZEND_API int add_next_index_string(zval *arg, char *str, int duplicate);
-ZEND_API int add_next_index_stringl(zval *arg, char *str, uint length, int duplicate);
+ZEND_API int add_next_index_string(zval *arg, const char *str, int duplicate);
+ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length, int duplicate);
ZEND_API int add_next_index_zval(zval *arg, zval *value);
-ZEND_API int add_get_assoc_string_ex(zval *arg, char *key, uint key_len, char *str, void **dest, int duplicate);
-ZEND_API int add_get_assoc_stringl_ex(zval *arg, char *key, uint key_len, char *str, uint length, void **dest, int duplicate);
+ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate);
+ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, void **dest, int duplicate);
#define add_get_assoc_string(__arg, __key, __str, __dest, __duplicate) add_get_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __dest, __duplicate)
#define add_get_assoc_stringl(__arg, __key, __str, __length, __dest, __duplicate) add_get_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __dest, __duplicate)
ZEND_API int add_get_index_long(zval *arg, ulong idx, long l, void **dest);
ZEND_API int add_get_index_double(zval *arg, ulong idx, double d, void **dest);
-ZEND_API int add_get_index_string(zval *arg, ulong idx, char *str, void **dest, int duplicate);
-ZEND_API int add_get_index_stringl(zval *arg, ulong idx, char *str, uint length, void **dest, int duplicate);
+ZEND_API int add_get_index_string(zval *arg, ulong idx, const char *str, void **dest, int duplicate);
+ZEND_API int add_get_index_stringl(zval *arg, ulong idx, const char *str, uint length, void **dest, int duplicate);
ZEND_API int add_property_long_ex(zval *arg, char *key, uint key_len, long l TSRMLS_DC);
ZEND_API int add_property_null_ex(zval *arg, char *key, uint key_len TSRMLS_DC);
}
#define ZVAL_STRING(z, s, duplicate) { \
- char *__s=(s); \
+ const char *__s=(s); \
(z)->value.str.len = strlen(__s); \
- (z)->value.str.val = (duplicate?estrndup(__s, (z)->value.str.len):__s); \
+ (z)->value.str.val = (duplicate?estrndup(__s, (z)->value.str.len):(char*)__s); \
(z)->type = IS_STRING; \
}
#define ZVAL_STRINGL(z, s, l, duplicate) { \
- char *__s=(s); int __l=l; \
+ const char *__s=(s); int __l=l;\
(z)->value.str.len = __l; \
- (z)->value.str.val = (duplicate?estrndup(__s, __l):__s); \
+ (z)->value.str.val = (duplicate?estrndup(__s, __l):(char*)__s); \
(z)->type = IS_STRING; \
}
#include "zend_arg_defs.c"
-static zend_function_entry builtin_functions[] = {
+static const zend_function_entry builtin_functions[] = {
ZEND_FE(zend_version, NULL)
ZEND_FE(func_num_args, NULL)
ZEND_FE(func_get_arg, NULL)
zend_constant *val;
int module_number;
zval **modules;
- char **module_names;
+ const char **module_names;
zend_module_entry *module;
int i = 1;
{
zval **extension_name;
zend_module_entry *module;
- zend_function_entry *func;
+ const zend_function_entry *func;
if (ZEND_NUM_ARGS() != 1 || zend_get_parameters_ex(1, &extension_name)) {
ZEND_WRONG_PARAM_COUNT();
}
-int zend_get_class_fetch_type(char *class_name, uint class_name_len)
+int zend_get_class_fetch_type(const char *class_name, uint class_name_len)
{
if ((class_name_len == sizeof("self")-1) &&
!memcmp(class_name, "self", sizeof("self"))) {
typedef struct _zend_arg_info {
- char *name;
+ const char *name;
zend_uint name_len;
- char *class_name;
+ const char *class_name;
zend_uint class_name_len;
zend_bool array_type_hint;
zend_bool allow_null;
ZEND_API zend_bool zend_is_compiling(TSRMLS_D);
ZEND_API char *zend_make_compiled_string_description(char *name TSRMLS_DC);
ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC);
-int zend_get_class_fetch_type(char *class_name, uint class_name_len);
+int zend_get_class_fetch_type(const char *class_name, uint class_name_len);
typedef zend_bool (*zend_auto_global_callback)(char *name, uint name_len TSRMLS_DC);
typedef struct _zend_auto_global {
ZEND_ARG_INFO(0, code)
ZEND_END_ARG_INFO()
-static zend_function_entry default_exception_functions[] = {
+const static zend_function_entry default_exception_functions[] = {
ZEND_ME(exception, __clone, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
ZEND_ME(exception, __construct, arginfo_exception___construct, ZEND_ACC_PUBLIC)
ZEND_ME(exception, getMessage, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
ZEND_ARG_INFO(0, lineno)
ZEND_END_ARG_INFO()
-static zend_function_entry error_exception_functions[] = {
+static const zend_function_entry error_exception_functions[] = {
ZEND_ME(error_exception, __construct, arginfo_error_exception___construct, ZEND_ACC_PUBLIC)
ZEND_ME(error_exception, getSeverity, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL)
{NULL, NULL, NULL}
}
}
-static inline char * zend_verify_arg_class_kind(zend_arg_info *cur_arg_info, char **class_name, zend_class_entry **pce TSRMLS_DC)
+static inline char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, const char **class_name, zend_class_entry **pce TSRMLS_DC)
{
*pce = zend_fetch_class(cur_arg_info->class_name, cur_arg_info->class_name_len, (ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD) TSRMLS_CC);
}
}
-static inline int zend_verify_arg_error(zend_function *zf, zend_uint arg_num, zend_arg_info *cur_arg_info, char *need_msg, char *need_kind, char *given_msg, char *given_kind TSRMLS_DC)
+static inline int zend_verify_arg_error(zend_function *zf, zend_uint arg_num, const zend_arg_info *cur_arg_info, const char *need_msg, const char *need_kind, char *given_msg, char *given_kind TSRMLS_DC)
{
zend_execute_data *ptr = EG(current_execute_data)->prev_execute_data;
char *fname = zf->common.function_name;
cur_arg_info = &zf->common.arg_info[arg_num-1];
if (cur_arg_info->class_name) {
- char *class_name;
+ const char *class_name;
if (!arg) {
need_msg = zend_verify_arg_class_kind(cur_arg_info, &class_name, &ce TSRMLS_CC);
FREE_ZVAL_REL(p);
}
}
-ZEND_API int zend_lookup_class(char *name, int name_length, zend_class_entry ***ce TSRMLS_DC);
-ZEND_API int zend_lookup_class_ex(char *name, int name_length, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
+ZEND_API int zend_lookup_class(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC);
+ZEND_API int zend_lookup_class_ex(const char *name, int name_length, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
ZEND_API void zend_set_timeout(long seconds);
ZEND_API void zend_unset_timeout(TSRMLS_D);
ZEND_API void zend_timeout(int dummy);
-ZEND_API zend_class_entry *zend_fetch_class(char *class_name, uint class_name_len, int fetch_type TSRMLS_DC);
+ZEND_API zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len, int fetch_type TSRMLS_DC);
void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC);
#ifdef ZEND_WIN32
}
-ZEND_API int zend_lookup_class_ex(char *name, int name_length, int use_autoload, zend_class_entry ***ce TSRMLS_DC)
+ZEND_API int zend_lookup_class_ex(const char *name, int name_length, int use_autoload, zend_class_entry ***ce TSRMLS_DC)
{
zval **args[1];
zval autoload_function;
return retval;
}
-ZEND_API int zend_lookup_class(char *name, int name_length, zend_class_entry ***ce TSRMLS_DC)
+ZEND_API int zend_lookup_class(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC)
{
return zend_lookup_class_ex(name, name_length, 1, ce TSRMLS_CC);
}
}
-zend_class_entry *zend_fetch_class(char *class_name, uint class_name_len, int fetch_type TSRMLS_DC)
+zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len, int fetch_type TSRMLS_DC)
{
zend_class_entry **pce;
int use_autoload = (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) == 0;
static int zend_hash_do_resize(HashTable *ht);
-ZEND_API ulong zend_hash_func(char *arKey, uint nKeyLength)
+ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength)
{
return zend_inline_hash_func(arKey, nKeyLength);
}
-ZEND_API int _zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
{
ulong h;
uint nIndex;
return SUCCESS;
}
-ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
{
uint nIndex;
Bucket *p;
}
-ZEND_API int zend_hash_add_empty_element(HashTable *ht, char *arKey, uint nKeyLength)
+ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, uint nKeyLength)
{
void *dummy = (void *) 1;
return SUCCESS;
}
-ZEND_API int zend_hash_del_key_or_index(HashTable *ht, char *arKey, uint nKeyLength, ulong h, int flag)
+ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, int flag)
{
uint nIndex;
Bucket *p;
}
-ZEND_API ulong zend_get_hash_value(char *arKey, uint nKeyLength)
+ZEND_API ulong zend_get_hash_value(const char *arKey, uint nKeyLength)
{
return zend_inline_hash_func(arKey, nKeyLength);
}
* data is returned in pData. The reason is that there's no reason
* someone using the hash table might not want to have NULL data
*/
-ZEND_API int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData)
+ZEND_API int zend_hash_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData)
{
ulong h;
uint nIndex;
}
-ZEND_API int zend_hash_quick_find(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void **pData)
+ZEND_API int zend_hash_quick_find(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void **pData)
{
uint nIndex;
Bucket *p;
}
-ZEND_API int zend_hash_exists(HashTable *ht, char *arKey, uint nKeyLength)
+ZEND_API int zend_hash_exists(HashTable *ht, const char *arKey, uint nKeyLength)
{
ulong h;
uint nIndex;
}
-ZEND_API int zend_hash_quick_exists(HashTable *ht, char *arKey, uint nKeyLength, ulong h)
+ZEND_API int zend_hash_quick_exists(HashTable *ht, const char *arKey, uint nKeyLength, ulong h)
{
uint nIndex;
Bucket *p;
/* This function changes key of currevt element without changing elements'
* order. If element with target key already exists, it will be deleted first.
*/
-ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, char *str_index, uint str_length, ulong num_index, HashPosition *pos)
+ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, uint str_length, ulong num_index, HashPosition *pos)
{
Bucket *p;
#define HASH_DEL_KEY 0
#define HASH_DEL_INDEX 1
-typedef ulong (*hash_func_t)(char *arKey, uint nKeyLength);
+typedef ulong (*hash_func_t)(const char *arKey, uint nKeyLength);
typedef int (*compare_func_t)(const void *, const void * TSRMLS_DC);
typedef void (*sort_func_t)(void *, size_t, register size_t, compare_func_t TSRMLS_DC);
typedef void (*dtor_func_t)(void *pDest);
#define zend_hash_init_ex(ht, nSize, pHashFunction, pDestructor, persistent, bApplyProtection) _zend_hash_init_ex((ht), (nSize), (pHashFunction), (pDestructor), (persistent), (bApplyProtection) ZEND_FILE_LINE_CC)
/* additions/updates/changes */
-ZEND_API int _zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
+ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
#define zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
_zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
#define zend_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
_zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
-ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
+ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
#define zend_hash_quick_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
_zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
#define zend_hash_quick_add(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
#define zend_hash_next_index_insert(ht, pData, nDataSize, pDest) \
_zend_hash_index_update_or_next_insert(ht, 0, pData, nDataSize, pDest, HASH_NEXT_INSERT ZEND_FILE_LINE_CC)
-ZEND_API int zend_hash_add_empty_element(HashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, uint nKeyLength);
#define ZEND_HASH_APPLY_KEEP 0
/* Deletes */
-ZEND_API int zend_hash_del_key_or_index(HashTable *ht, char *arKey, uint nKeyLength, ulong h, int flag);
+ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, int flag);
#define zend_hash_del(ht, arKey, nKeyLength) \
zend_hash_del_key_or_index(ht, arKey, nKeyLength, 0, HASH_DEL_KEY)
#define zend_hash_index_del(ht, h) \
zend_hash_del_key_or_index(ht, NULL, 0, h, HASH_DEL_INDEX)
-ZEND_API ulong zend_get_hash_value(char *arKey, uint nKeyLength);
+ZEND_API ulong zend_get_hash_value(const char *arKey, uint nKeyLength);
/* Data retreival */
-ZEND_API int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_hash_quick_find(HashTable *ht, char *arKey, uint nKeyLength, ulong h, void **pData);
+ZEND_API int zend_hash_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
+ZEND_API int zend_hash_quick_find(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void **pData);
ZEND_API int zend_hash_index_find(HashTable *ht, ulong h, void **pData);
/* Misc */
-ZEND_API int zend_hash_exists(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_hash_quick_exists(HashTable *ht, char *arKey, uint nKeyLength, ulong h);
+ZEND_API int zend_hash_exists(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_hash_quick_exists(HashTable *ht, const char *arKey, uint nKeyLength, ulong h);
ZEND_API int zend_hash_index_exists(HashTable *ht, ulong h);
ZEND_API ulong zend_hash_next_free_element(HashTable *ht);
ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos);
ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos);
ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, char *str_index, uint str_length, ulong num_index, HashPosition *pos);
+ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, uint str_length, ulong num_index, HashPosition *pos);
typedef struct _HashPointer {
HashPosition pos;
* -- Ralf S. Engelschall <rse@engelschall.com>
*/
-static inline ulong zend_inline_hash_func(char *arKey, uint nKeyLength)
+static inline ulong zend_inline_hash_func(const char *arKey, uint nKeyLength)
{
register ulong hash = 5381;
}
-ZEND_API ulong zend_hash_func(char *arKey, uint nKeyLength);
+ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength);
#if ZEND_DEBUG
/* debug */
#define HANDLE_NUMERIC(key, length, func) { \
- register char *tmp=key; \
+ register const char *tmp=key; \
\
if (*tmp=='-') { \
tmp++; \
} \
if ((*tmp>='0' && *tmp<='9')) do { /* possibly a numeric index */ \
- char *end=key+length-1; \
+ const char *end=key+length-1; \
long idx; \
\
if (*tmp++=='0' && length>2) { /* don't accept numbers with leading zeros */ \
}
-static inline int zend_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest) \
+static inline int zend_symtable_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest) \
{
HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_update(ht, idx, pData, nDataSize, pDest));
return zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest);
}
-static inline int zend_symtable_del(HashTable *ht, char *arKey, uint nKeyLength)
+static inline int zend_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength)
{
HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_del(ht, idx))
return zend_hash_del(ht, arKey, nKeyLength);
}
-static inline int zend_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData)
+static inline int zend_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData)
{
HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData));
return zend_hash_find(ht, arKey, nKeyLength, pData);
}
-static inline int zend_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength)
+static inline int zend_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength)
{
HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx));
return zend_hash_exists(ht, arKey, nKeyLength);
}
-static inline int zend_symtable_update_current_key(HashTable *ht, char *arKey, uint nKeyLength)
+static inline int zend_symtable_update_current_key(HashTable *ht, const char *arKey, uint nKeyLength)
{
HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_update_current_key(ht, HASH_KEY_IS_LONG, NULL, 0, idx));
return zend_hash_update_current_key(ht, HASH_KEY_IS_STRING, arKey, nKeyLength, 0);
/*
* Registration / unregistration
*/
-ZEND_API int zend_register_ini_entries(zend_ini_entry *ini_entry, int module_number TSRMLS_DC) /* {{{ */
+ZEND_API int zend_register_ini_entries(const zend_ini_entry *ini_entry, int module_number TSRMLS_DC) /* {{{ */
{
- zend_ini_entry *p = ini_entry;
+ const zend_ini_entry *p = ini_entry;
zend_ini_entry *hashed_ini_entry;
zval default_value;
HashTable *directives = registered_zend_ini_directives;
#endif
while (p->name) {
- p->module_number = module_number;
config_directive_success = 0;
- if (zend_hash_add(directives, p->name, p->name_length, p, sizeof(zend_ini_entry), (void **) &hashed_ini_entry) == FAILURE) {
+ if (zend_hash_add(directives, p->name, p->name_length, (void*)p, sizeof(zend_ini_entry), (void **) &hashed_ini_entry) == FAILURE) {
zend_unregister_ini_entries(module_number TSRMLS_CC);
return FAILURE;
}
+ hashed_ini_entry->module_number = module_number;
if ((zend_get_configuration_directive(p->name, p->name_length, &default_value)) == SUCCESS) {
if (!hashed_ini_entry->on_modify
|| hashed_ini_entry->on_modify(hashed_ini_entry, Z_STRVAL(default_value), Z_STRLEN(default_value), hashed_ini_entry->mh_arg1, hashed_ini_entry->mh_arg2, hashed_ini_entry->mh_arg3, ZEND_INI_STAGE_STARTUP TSRMLS_CC) == SUCCESS) {
ZEND_API void zend_ini_sort_entries(TSRMLS_D);
-ZEND_API int zend_register_ini_entries(zend_ini_entry *ini_entry, int module_number TSRMLS_DC);
+ZEND_API int zend_register_ini_entries(const zend_ini_entry *ini_entry, int module_number TSRMLS_DC);
ZEND_API void zend_unregister_ini_entries(int module_number TSRMLS_DC);
ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC);
ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage);
ZEND_API ZEND_INI_DISP(display_link_numbers);
END_EXTERN_C()
-#define ZEND_INI_BEGIN() static zend_ini_entry ini_entries[] = {
+#define ZEND_INI_BEGIN() static const zend_ini_entry ini_entries[] = {
#define ZEND_INI_END() { 0, 0, NULL, 0, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0, 0, NULL } };
#define ZEND_INI_ENTRY3_EX(name, default_value, modifiable, on_modify, arg1, arg2, arg3, displayer) \
/* }}}*/
/* {{{ function tables */
-zend_function_entry zend_funcs_aggregate[] = {
+const zend_function_entry zend_funcs_aggregate[] = {
ZEND_ABSTRACT_ME(iterator, getIterator, NULL)
{NULL, NULL, NULL}
};
-zend_function_entry zend_funcs_iterator[] = {
+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)
{NULL, NULL, NULL}
};
-zend_function_entry *zend_funcs_traversable = NULL;
+const zend_function_entry *zend_funcs_traversable = NULL;
static
ZEND_BEGIN_ARG_INFO_EX(arginfo_arrayaccess_offset, 0, 0, 1)
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
-zend_function_entry zend_funcs_arrayaccess[] = {
+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()
-zend_function_entry zend_funcs_serializable[] = {
+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)
{NULL, NULL, NULL}
#define ZEND_MODULE_INFO_FUNC_ARGS zend_module_entry *zend_module TSRMLS_DC
#define ZEND_MODULE_INFO_FUNC_ARGS_PASSTHRU zend_module TSRMLS_CC
-extern struct _zend_arg_info first_arg_force_ref[2];
-extern struct _zend_arg_info second_arg_force_ref[3];
-extern struct _zend_arg_info third_arg_force_ref[4];
-extern struct _zend_arg_info fourth_arg_force_ref[5];
-extern struct _zend_arg_info fifth_arg_force_ref[6];
-extern struct _zend_arg_info all_args_by_ref[1];
+extern const struct _zend_arg_info first_arg_force_ref[2];
+extern const struct _zend_arg_info second_arg_force_ref[3];
+extern const struct _zend_arg_info third_arg_force_ref[4];
+extern const struct _zend_arg_info fourth_arg_force_ref[5];
+extern const struct _zend_arg_info fifth_arg_force_ref[6];
+extern const struct _zend_arg_info all_args_by_ref[1];
#define ZEND_MODULE_API_NO 20060613
#ifdef ZTS
unsigned int zend_api;
unsigned char zend_debug;
unsigned char zts;
- struct _zend_ini_entry *ini_entry;
- struct _zend_module_dep *deps;
- char *name;
- struct _zend_function_entry *functions;
+ const struct _zend_ini_entry *ini_entry;
+ const struct _zend_module_dep *deps;
+ const char *name;
+ const struct _zend_function_entry *functions;
int (*module_startup_func)(INIT_FUNC_ARGS);
int (*module_shutdown_func)(SHUTDOWN_FUNC_ARGS);
int (*request_startup_func)(INIT_FUNC_ARGS);
int (*request_shutdown_func)(SHUTDOWN_FUNC_ARGS);
void (*info_func)(ZEND_MODULE_INFO_FUNC_ARGS);
- char *version;
+ const char *version;
size_t globals_size;
#ifdef ZTS
ts_rsrc_id* globals_id_ptr;
#define ZEND_MOD_OPTIONAL(name) ZEND_MOD_OPTIONAL_EX(name, NULL, NULL)
struct _zend_module_dep {
- char *name; /* module name */
- char *rel; /* version relationship: NULL (exists), lt|le|eq|ge|gt (to given version) */
- char *version; /* version */
- unsigned char type; /* dependency type */
+ const char *name; /* module name */
+ const char *rel; /* version relationship: NULL (exists), lt|le|eq|ge|gt (to given version) */
+ const char *version; /* version */
+ unsigned char type; /* dependency type */
};
extern ZEND_API HashTable module_registry;
}
if (op_array->arg_info) {
for (i=0; i<op_array->num_args; i++) {
- efree(op_array->arg_info[i].name);
+ efree((char*)op_array->arg_info[i].name);
if (op_array->arg_info[i].class_name) {
- efree(op_array->arg_info[i].class_name);
+ efree((char*)op_array->arg_info[i].class_name);
}
}
efree(op_array->arg_info);
/* }}} */
-zend_function_entry bcmath_functions[] = {
+const zend_function_entry bcmath_functions[] = {
PHP_FE(bcadd, arginfo_bcadd)
PHP_FE(bcsub, arginfo_bcsub)
PHP_FE(bcmul, arginfo_bcmul)
/* }}} */
-static zend_function_entry bz2_functions[] = {
+static const zend_function_entry bz2_functions[] = {
PHP_FE(bzopen, arginfo_bzopen)
PHP_FE(bzread, arginfo_bzread)
PHP_FALIAS(bzwrite, fwrite, NULL)
/* }}} */
-zend_function_entry calendar_functions[] = {
+const zend_function_entry calendar_functions[] = {
PHP_FE(jdtogregorian, arginfo_jdtogregorian)
PHP_FE(gregoriantojd, arginfo_gregoriantojd)
PHP_FE(jdtojulian, arginfo_jdtojulian)
*php_com_exception_class_entry,
*php_com_saproxy_class_entry;
-zend_function_entry com_dotnet_functions[] = {
+const zend_function_entry com_dotnet_functions[] = {
PHP_FE(variant_set, NULL)
PHP_FE(variant_add, NULL)
PHP_FE(variant_cat, NULL)
-static zend_function_entry com_persist_helper_methods[] = {
+static const zend_function_entry com_persist_helper_methods[] = {
CPH_ME(__construct, NULL)
CPH_ME(GetCurFileName, NULL)
CPH_ME(SaveToFile, NULL)
/* {{{ ctype_functions[]
* Every user visible function must have an entry in ctype_functions[].
*/
-static zend_function_entry ctype_functions[] = {
+static const zend_function_entry ctype_functions[] = {
PHP_FE(ctype_alnum, arginfo_ctype_alnum)
PHP_FE(ctype_alpha, arginfo_ctype_alpha)
PHP_FE(ctype_cntrl, arginfo_ctype_cntrl)
/* {{{ curl_functions[]
*/
-zend_function_entry curl_functions[] = {
+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 */
-zend_function_entry date_functions[] = {
+const zend_function_entry date_functions[] = {
PHP_FE(strtotime, arginfo_strtotime)
PHP_FE(date, arginfo_date)
PHP_FE(idate, arginfo_idate)
{NULL, NULL, NULL}
};
-zend_function_entry date_funcs_date[] = {
+const zend_function_entry date_funcs_date[] = {
PHP_ME(DateTime, __construct, NULL, ZEND_ACC_CTOR|ZEND_ACC_PUBLIC)
PHP_ME_MAPPING(format, date_format, NULL, 0)
PHP_ME_MAPPING(modify, date_modify, NULL, 0)
{NULL, NULL, NULL}
};
-zend_function_entry date_funcs_timezone[] = {
+const zend_function_entry date_funcs_timezone[] = {
PHP_ME(DateTimeZone, __construct, NULL, ZEND_ACC_CTOR|ZEND_ACC_PUBLIC)
PHP_ME_MAPPING(getName, timezone_name_get, NULL, 0)
PHP_ME_MAPPING(getOffset, timezone_offset_get, NULL, 0)
static zend_object_value date_object_clone_timezone(zval *this_ptr TSRMLS_DC);
/* This is need to ensure that session extension request shutdown occurs 1st, because it uses the date extension */
-static zend_module_dep date_deps[] = {
+static const zend_module_dep date_deps[] = {
ZEND_MOD_OPTIONAL("session")
{NULL, NULL, NULL}
};
/* {{{ dba_functions[]
*/
-zend_function_entry dba_functions[] = {
+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)
/* {{{ dbase_functions[]
*/
-zend_function_entry dbase_functions[] = {
+const zend_function_entry dbase_functions[] = {
PHP_FE(dbase_open, arginfo_dbase_open)
PHP_FE(dbase_create, arginfo_dbase_create)
PHP_FE(dbase_close, arginfo_dbase_close)
* Since:
*/
-zend_function_entry php_dom_attr_class_functions[] = {
+const zend_function_entry php_dom_attr_class_functions[] = {
PHP_FALIAS(isId, dom_attr_is_id, NULL)
PHP_ME(domattr, __construct, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
* Since:
*/
-zend_function_entry php_dom_cdatasection_class_functions[] = {
+const zend_function_entry php_dom_cdatasection_class_functions[] = {
PHP_ME(domcdatasection, __construct, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
* Since:
*/
-zend_function_entry php_dom_characterdata_class_functions[] = {
+const zend_function_entry php_dom_characterdata_class_functions[] = {
PHP_FALIAS(substringData, dom_characterdata_substring_data, NULL)
PHP_FALIAS(appendData, dom_characterdata_append_data, NULL)
PHP_FALIAS(insertData, dom_characterdata_insert_data, NULL)
* Since:
*/
-zend_function_entry php_dom_comment_class_functions[] = {
+const zend_function_entry php_dom_comment_class_functions[] = {
PHP_ME(domcomment, __construct, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
* Since:
*/
-zend_function_entry php_dom_document_class_functions[] = {
+const zend_function_entry php_dom_document_class_functions[] = {
PHP_FALIAS(createElement, dom_document_create_element, NULL)
PHP_FALIAS(createDocumentFragment, dom_document_create_document_fragment, NULL)
PHP_FALIAS(createTextNode, dom_document_create_text_node, NULL)
* Since:
*/
-zend_function_entry php_dom_documentfragment_class_functions[] = {
+const zend_function_entry php_dom_documentfragment_class_functions[] = {
PHP_ME(domdocumentfragment, __construct, NULL, ZEND_ACC_PUBLIC)
PHP_ME(domdocumentfragment, appendXML, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
* Since:
*/
-zend_function_entry php_dom_documenttype_class_functions[] = {
+const zend_function_entry php_dom_documenttype_class_functions[] = {
{NULL, NULL, NULL}
};
#ifndef DOM_FE_H
#define DOM_FE_H
-extern zend_function_entry php_dom_domexception_class_functions[];
-extern zend_function_entry php_dom_domstringlist_class_functions[];
-extern zend_function_entry php_dom_namelist_class_functions[];
-extern zend_function_entry php_dom_domimplementationlist_class_functions[];
-extern zend_function_entry php_dom_domimplementationsource_class_functions[];
-extern zend_function_entry php_dom_domimplementation_class_functions[];
-extern zend_function_entry php_dom_documentfragment_class_functions[];
-extern zend_function_entry php_dom_document_class_functions[];
-extern zend_function_entry php_dom_node_class_functions[];
-extern zend_function_entry php_dom_nodelist_class_functions[];
-extern zend_function_entry php_dom_namednodemap_class_functions[];
-extern zend_function_entry php_dom_characterdata_class_functions[];
-extern zend_function_entry php_dom_attr_class_functions[];
-extern zend_function_entry php_dom_element_class_functions[];
-extern zend_function_entry php_dom_text_class_functions[];
-extern zend_function_entry php_dom_comment_class_functions[];
-extern zend_function_entry php_dom_typeinfo_class_functions[];
-extern zend_function_entry php_dom_userdatahandler_class_functions[];
-extern zend_function_entry php_dom_domerror_class_functions[];
-extern zend_function_entry php_dom_domerrorhandler_class_functions[];
-extern zend_function_entry php_dom_domlocator_class_functions[];
-extern zend_function_entry php_dom_domconfiguration_class_functions[];
-extern zend_function_entry php_dom_cdatasection_class_functions[];
-extern zend_function_entry php_dom_documenttype_class_functions[];
-extern zend_function_entry php_dom_notation_class_functions[];
-extern zend_function_entry php_dom_entity_class_functions[];
-extern zend_function_entry php_dom_entityreference_class_functions[];
-extern zend_function_entry php_dom_processinginstruction_class_functions[];
-extern zend_function_entry php_dom_string_extend_class_functions[];
-extern zend_function_entry php_dom_xpath_class_functions[];
+extern const zend_function_entry php_dom_domexception_class_functions[];
+extern const zend_function_entry php_dom_domstringlist_class_functions[];
+extern const zend_function_entry php_dom_namelist_class_functions[];
+extern const zend_function_entry php_dom_domimplementationlist_class_functions[];
+extern const zend_function_entry php_dom_domimplementationsource_class_functions[];
+extern const zend_function_entry php_dom_domimplementation_class_functions[];
+extern const zend_function_entry php_dom_documentfragment_class_functions[];
+extern const zend_function_entry php_dom_document_class_functions[];
+extern const zend_function_entry php_dom_node_class_functions[];
+extern const zend_function_entry php_dom_nodelist_class_functions[];
+extern const zend_function_entry php_dom_namednodemap_class_functions[];
+extern const zend_function_entry php_dom_characterdata_class_functions[];
+extern const zend_function_entry php_dom_attr_class_functions[];
+extern const zend_function_entry php_dom_element_class_functions[];
+extern const zend_function_entry php_dom_text_class_functions[];
+extern const zend_function_entry php_dom_comment_class_functions[];
+extern const zend_function_entry php_dom_typeinfo_class_functions[];
+extern const zend_function_entry php_dom_userdatahandler_class_functions[];
+extern const zend_function_entry php_dom_domerror_class_functions[];
+extern const zend_function_entry php_dom_domerrorhandler_class_functions[];
+extern const zend_function_entry php_dom_domlocator_class_functions[];
+extern const zend_function_entry php_dom_domconfiguration_class_functions[];
+extern const zend_function_entry php_dom_cdatasection_class_functions[];
+extern const zend_function_entry php_dom_documenttype_class_functions[];
+extern const zend_function_entry php_dom_notation_class_functions[];
+extern const zend_function_entry php_dom_entity_class_functions[];
+extern const zend_function_entry php_dom_entityreference_class_functions[];
+extern const zend_function_entry php_dom_processinginstruction_class_functions[];
+extern const zend_function_entry php_dom_string_extend_class_functions[];
+extern const zend_function_entry php_dom_xpath_class_functions[];
/* domexception errors */
typedef enum {
* Since: DOM Level 3
*/
-zend_function_entry php_dom_domconfiguration_class_functions[] = {
+const zend_function_entry php_dom_domconfiguration_class_functions[] = {
PHP_FALIAS(setParameter, dom_domconfiguration_set_parameter, NULL)
PHP_FALIAS(getParameter, dom_domconfiguration_get_parameter, NULL)
PHP_FALIAS(canSetParameter, dom_domconfiguration_can_set_parameter, NULL)
* Since: DOM Level 3
*/
-zend_function_entry php_dom_domerror_class_functions[] = {
+const zend_function_entry php_dom_domerror_class_functions[] = {
{NULL, NULL, NULL}
};
* Since: DOM Level 3
*/
-zend_function_entry php_dom_domerrorhandler_class_functions[] = {
+const zend_function_entry php_dom_domerrorhandler_class_functions[] = {
PHP_FALIAS(handleError, dom_domerrorhandler_handle_error, NULL)
{NULL, NULL, NULL}
};
extern zend_class_entry *dom_domexception_class_entry;
-zend_function_entry php_dom_domexception_class_functions[] = {
+const zend_function_entry php_dom_domexception_class_functions[] = {
{NULL, NULL, NULL}
};
* Since:
*/
-zend_function_entry php_dom_domimplementation_class_functions[] = {
+const zend_function_entry php_dom_domimplementation_class_functions[] = {
PHP_ME(domimplementation, getFeature, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_ALLOW_STATIC)
PHP_ME(domimplementation, hasFeature, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_ALLOW_STATIC)
PHP_ME(domimplementation, createDocumentType, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_ALLOW_STATIC)
* Since: DOM Level 3
*/
-zend_function_entry php_dom_domimplementationlist_class_functions[] = {
+const zend_function_entry php_dom_domimplementationlist_class_functions[] = {
PHP_FALIAS(item, dom_domimplementationlist_item, NULL)
{NULL, NULL, NULL}
};
* Since: DOM Level 3
*/
-zend_function_entry php_dom_domimplementationsource_class_functions[] = {
+const zend_function_entry php_dom_domimplementationsource_class_functions[] = {
PHP_FALIAS(getDomimplementation, dom_domimplementationsource_get_domimplementation, NULL)
PHP_FALIAS(getDomimplementations, dom_domimplementationsource_get_domimplementations, NULL)
{NULL, NULL, NULL}
* Since: DOM Level 3
*/
-zend_function_entry php_dom_domlocator_class_functions[] = {
+const zend_function_entry php_dom_domlocator_class_functions[] = {
{NULL, NULL, NULL}
};
* Since: DOM Level 3
*/
-zend_function_entry php_dom_domstringlist_class_functions[] = {
+const zend_function_entry php_dom_domstringlist_class_functions[] = {
PHP_FALIAS(item, dom_domstringlist_item, NULL)
{NULL, NULL, NULL}
};
* Since:
*/
-zend_function_entry php_dom_element_class_functions[] = {
+const zend_function_entry php_dom_element_class_functions[] = {
PHP_FALIAS(getAttribute, dom_element_get_attribute, NULL)
PHP_FALIAS(setAttribute, dom_element_set_attribute, NULL)
PHP_FALIAS(removeAttribute, dom_element_remove_attribute, NULL)
* Since:
*/
-zend_function_entry php_dom_entity_class_functions[] = {
+const zend_function_entry php_dom_entity_class_functions[] = {
{NULL, NULL, NULL}
};
* Since:
*/
-zend_function_entry php_dom_entityreference_class_functions[] = {
+const zend_function_entry php_dom_entityreference_class_functions[] = {
PHP_ME(domentityreference, __construct, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
* Since:
*/
-zend_function_entry php_dom_namednodemap_class_functions[] = {
+const zend_function_entry php_dom_namednodemap_class_functions[] = {
PHP_FALIAS(getNamedItem, dom_namednodemap_get_named_item, NULL)
PHP_FALIAS(setNamedItem, dom_namednodemap_set_named_item, NULL)
PHP_FALIAS(removeNamedItem, dom_namednodemap_remove_named_item, NULL)
* Since: DOM Level 3
*/
-zend_function_entry php_dom_namelist_class_functions[] = {
+const zend_function_entry php_dom_namelist_class_functions[] = {
PHP_FALIAS(getName, dom_namelist_get_name, NULL)
PHP_FALIAS(getNamespaceURI, dom_namelist_get_namespace_uri, NULL)
{NULL, NULL, NULL}
* Since:
*/
-zend_function_entry php_dom_node_class_functions[] = {
+const zend_function_entry php_dom_node_class_functions[] = {
PHP_FALIAS(insertBefore, dom_node_insert_before, NULL)
PHP_FALIAS(replaceChild, dom_node_replace_child, NULL)
PHP_FALIAS(removeChild, dom_node_remove_child, NULL)
* Since:
*/
-zend_function_entry php_dom_nodelist_class_functions[] = {
+const zend_function_entry php_dom_nodelist_class_functions[] = {
PHP_FALIAS(item, dom_nodelist_item, NULL)
{NULL, NULL, NULL}
};
* Since:
*/
-zend_function_entry php_dom_notation_class_functions[] = {
+const zend_function_entry php_dom_notation_class_functions[] = {
{NULL, NULL, NULL}
};
return zobject->value.obj;
}
-static zend_function_entry dom_functions[] = {
+static const zend_function_entry dom_functions[] = {
PHP_FE(dom_import_simplexml, NULL)
{NULL, NULL, NULL}
};
}
}
-static zend_module_dep dom_deps[] = {
+static const zend_module_dep dom_deps[] = {
ZEND_MOD_REQUIRED("libxml")
ZEND_MOD_CONFLICTS("domxml")
{NULL, NULL, NULL}
* Since:
*/
-zend_function_entry php_dom_processinginstruction_class_functions[] = {
+const zend_function_entry php_dom_processinginstruction_class_functions[] = {
PHP_ME(domprocessinginstruction, __construct, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
* Since:
*/
-zend_function_entry php_dom_string_extend_class_functions[] = {
+const zend_function_entry php_dom_string_extend_class_functions[] = {
PHP_FALIAS(findOffset16, dom_string_extend_find_offset16, NULL)
PHP_FALIAS(findOffset32, dom_string_extend_find_offset32, NULL)
{NULL, NULL, NULL}
* Since:
*/
-zend_function_entry php_dom_text_class_functions[] = {
+const zend_function_entry php_dom_text_class_functions[] = {
PHP_FALIAS(splitText, dom_text_split_text, NULL)
PHP_FALIAS(isWhitespaceInElementContent, dom_text_is_whitespace_in_element_content, NULL)
PHP_FALIAS(isElementContentWhitespace, dom_text_is_whitespace_in_element_content, NULL)
* Since: DOM Level 3
*/
-zend_function_entry php_dom_typeinfo_class_functions[] = {
+const zend_function_entry php_dom_typeinfo_class_functions[] = {
{NULL, NULL, NULL}
};
* Since: DOM Level 3
*/
-zend_function_entry php_dom_userdatahandler_class_functions[] = {
+const zend_function_entry php_dom_userdatahandler_class_functions[] = {
PHP_FALIAS(handle, dom_userdatahandler_handle, NULL)
{NULL, NULL, NULL}
};
#if defined(LIBXML_XPATH_ENABLED)
-zend_function_entry php_dom_xpath_class_functions[] = {
+const zend_function_entry php_dom_xpath_class_functions[] = {
PHP_ME(domxpath, __construct, NULL, ZEND_ACC_PUBLIC)
PHP_FALIAS(registerNamespace, dom_xpath_register_ns, NULL)
PHP_FALIAS(query, dom_xpath_query, NULL)
/* {{{ exif_functions[]
*/
-zend_function_entry exif_functions[] = {
+const zend_function_entry exif_functions[] = {
PHP_FE(exif_read_data, arginfo_exif_read_data)
PHP_FALIAS(read_exif_data, exif_read_data, arginfo_exif_read_data)
PHP_FE(exif_tagname, arginfo_exif_tagname)
/* {{{ fbsql_functions[]
*/
-zend_function_entry fbsql_functions[] = {
+const zend_function_entry fbsql_functions[] = {
PHP_FE(fbsql_connect, arginfo_fbsql_connect)
PHP_FE(fbsql_pconnect, arginfo_fbsql_pconnect)
PHP_FE(fbsql_close, arginfo_fbsql_close)
/* {{{ fdf_functions[]
*/
-zend_function_entry fdf_functions[] = {
+const zend_function_entry fdf_functions[] = {
PHP_FE(fdf_add_template, arginfo_fdf_add_template)
PHP_FE(fdf_close, arginfo_fdf_close)
PHP_FE(fdf_create, arginfo_fdf_create)
/* {{{ filter_functions[]
*/
-zend_function_entry filter_functions[] = {
+const zend_function_entry filter_functions[] = {
PHP_FE(filter_input, NULL)
PHP_FE(filter_var, NULL)
PHP_FE(filter_input_array, NULL)
/* }}} */
-zend_function_entry php_ftp_functions[] = {
+const zend_function_entry php_ftp_functions[] = {
PHP_FE(ftp_connect, arginfo_ftp_connect)
#if HAVE_OPENSSL_EXT
PHP_FE(ftp_ssl_connect, arginfo_ftp_ssl_connect)
/* {{{ gd_functions[]
*/
-zend_function_entry gd_functions[] = {
+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[]
*/
-zend_function_entry php_gettext_functions[] = {
+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[]
*/
-zend_function_entry gmp_functions[] = {
+const zend_function_entry gmp_functions[] = {
ZEND_FE(gmp_init, arginfo_gmp_init)
ZEND_FE(gmp_intval, arginfo_gmp_intval)
ZEND_FE(gmp_strval, arginfo_gmp_strval)
/* {{{ hash_functions[]
*/
-zend_function_entry hash_functions[] = {
+const zend_function_entry hash_functions[] = {
PHP_FE(hash, arginfo_hash)
PHP_FE(hash_file, arginfo_hash_file)
/* {{{ iconv_functions[]
*/
-zend_function_entry iconv_functions[] = {
+const zend_function_entry iconv_functions[] = {
PHP_RAW_NAMED_FE(iconv,php_if_iconv, arginfo_iconv)
PHP_FE(ob_iconv_handler, arginfo_ob_iconv_handler)
PHP_FE(iconv_get_encoding, arginfo_iconv_get_encoding)
/* {{{ imap_functions[]
*/
-zend_function_entry imap_functions[] = {
+const zend_function_entry imap_functions[] = {
PHP_FE(imap_open, NULL)
PHP_FE(imap_reopen, NULL)
PHP_FE(imap_close, NULL)
/* }}} */
/* {{{ imap dependencies */
-static zend_module_dep imap_deps[] = {
+static const zend_module_dep imap_deps[] = {
ZEND_MOD_REQUIRED("standard")
{NULL, NULL, NULL}
};
static PHP_GINIT_FUNCTION(ibase);
/* {{{ extension definition structures */
-zend_function_entry ibase_functions[] = {
+const zend_function_entry ibase_functions[] = {
PHP_FE(ibase_connect, NULL)
PHP_FE(ibase_pconnect, NULL)
PHP_FE(ibase_close, NULL)
*
* Every user visible function must have an entry in json_functions[].
*/
-static function_entry json_functions[] = {
+static const function_entry json_functions[] = {
PHP_FE(json_encode, NULL)
PHP_FE(json_decode, NULL)
{NULL, NULL, NULL} /* Must be the last line in json_functions[] */
*/
/* {{{ ldap_functions[]
*/
-zend_function_entry ldap_functions[] = {
+const zend_function_entry ldap_functions[] = {
PHP_FE(ldap_connect, NULL)
PHP_FALIAS(ldap_close, ldap_unbind, NULL)
PHP_FE(ldap_bind, NULL)
/* }}} */
/* {{{ extension definition structures */
-static zend_function_entry libxml_functions[] = {
+static const zend_function_entry libxml_functions[] = {
PHP_FE(libxml_set_streams_context, arginfo_libxml_set_streams_context)
PHP_FE(libxml_use_internal_errors, arginfo_libxml_use_internal_errors)
PHP_FE(libxml_get_last_error, arginfo_libxml_get_last_error)
/* }}} */
/* {{{ zend_function_entry mbstring_functions[] */
-zend_function_entry mbstring_functions[] = {
+const zend_function_entry mbstring_functions[] = {
PHP_FE(mb_convert_case, NULL)
PHP_FE(mb_strtoupper, NULL)
PHP_FE(mb_strtolower, NULL)
zend_bool init;
} php_mcrypt;
-zend_function_entry mcrypt_functions[] = { /* {{{ */
+const zend_function_entry mcrypt_functions[] = { /* {{{ */
PHP_FE(mcrypt_ecb, NULL)
PHP_FE(mcrypt_cbc, NULL)
PHP_FE(mcrypt_cfb, NULL)
#include "php_globals.h"
#include "ext/standard/info.h"
-zend_function_entry mhash_functions[] = {
+const zend_function_entry mhash_functions[] = {
PHP_FE(mhash_get_block_size, NULL)
PHP_FE(mhash_get_hash_name, NULL)
PHP_FE(mhash_keygen_s2k, NULL)
static magic_server_config_rec mime_global;
/* {{{ mime_magic_functions[] */
-zend_function_entry mime_magic_functions[] = {
+const zend_function_entry mime_magic_functions[] = {
PHP_FE(mime_content_type, NULL)
{NULL, NULL, NULL}
};
void destroySWFBlock(SWFBlock block);
#endif
-static zend_function_entry ming_functions[] = {
+static const zend_function_entry ming_functions[] = {
PHP_FALIAS(ming_setcubicthreshold, ming_setCubicThreshold, NULL)
PHP_FALIAS(ming_setscale, ming_setScale, NULL)
PHP_FALIAS(ming_useswfversion, ming_useSWFVersion, NULL)
}
/* }}} */
-static zend_function_entry swfaction_functions[] = {
+static const zend_function_entry swfaction_functions[] = {
PHP_ME(swfaction, __construct, NULL, 0)
{ NULL, NULL, NULL }
};
}
/* }}} */
-static zend_function_entry swfbitmap_functions[] = {
+static const zend_function_entry swfbitmap_functions[] = {
PHP_ME(swfbitmap, __construct, NULL, 0)
PHP_ME(swfbitmap, getWidth, NULL, 0)
PHP_ME(swfbitmap, getHeight, NULL, 0)
}
/* }}} */
-static zend_function_entry swfbutton_functions[] = {
+static const zend_function_entry swfbutton_functions[] = {
PHP_ME(swfbutton, __construct, NULL, 0)
PHP_ME(swfbutton, setHit, NULL, 0)
PHP_ME(swfbutton, setOver, NULL, 0)
/* }}} */
#endif
-static zend_function_entry swfdisplayitem_functions[] = {
+static const zend_function_entry swfdisplayitem_functions[] = {
PHP_ME(swfdisplayitem, moveTo, NULL, 0)
PHP_ME(swfdisplayitem, move, NULL, 0)
PHP_ME(swfdisplayitem, scaleTo, NULL, 0)
SWFFill_skewYTo(getFill(getThis() TSRMLS_CC), FLOAT_Z_DVAL_PP(y));
}
/* }}} */
-static zend_function_entry swffill_functions[] = {
+static const zend_function_entry swffill_functions[] = {
PHP_ME(swffill, __construct, NULL, 0)
PHP_ME(swffill, moveTo, NULL, 0)
PHP_ME(swffill, scaleTo, NULL, 0)
}
/* }}} */
-static zend_function_entry swffontchar_functions[] = {
+static const zend_function_entry swffontchar_functions[] = {
PHP_ME(swffontchar, addChars, NULL, 0)
PHP_ME(swffontchar, addUTF8Chars, NULL, 0)
{ NULL, NULL, NULL }
#endif
-static zend_function_entry swffont_functions[] = {
+static const zend_function_entry swffont_functions[] = {
PHP_ME(swffont, __construct, NULL, 0)
PHP_ME(swffont, getWidth, NULL, 0)
#ifdef HAVE_NEW_MING
}
/* }}} */
-static zend_function_entry swfgradient_functions[] = {
+static const zend_function_entry swfgradient_functions[] = {
PHP_ME(swfgradient, __construct, NULL, 0)
PHP_ME(swfgradient, addEntry, NULL, 0)
{ NULL, NULL, NULL }
}
/* }}} */
-static zend_function_entry swfmorph_functions[] = {
+static const zend_function_entry swfmorph_functions[] = {
PHP_ME(swfmorph, __construct, NULL, 0)
PHP_ME(swfmorph, getShape1, NULL, 0)
PHP_ME(swfmorph, getShape2, NULL, 0)
/* }}} */
-static zend_function_entry swfsound_functions[] = {
+static const zend_function_entry swfsound_functions[] = {
PHP_ME(swfsound, __construct, NULL, 0)
{ NULL, NULL, NULL }
};
}
/* }}} */
-static zend_function_entry swfsoundinstance_functions[] = {
+static const zend_function_entry swfsoundinstance_functions[] = {
PHP_ME(swfsoundinstance, noMultiple, NULL, 0)
PHP_ME(swfsoundinstance, loopInPoint, NULL, 0)
PHP_ME(swfsoundinstance, loopOutPoint, NULL, 0)
/* }}} */
-static zend_function_entry swfvideostream_functions[] = {
+static const zend_function_entry swfvideostream_functions[] = {
PHP_ME(swfvideostream, __construct, NULL, 0)
PHP_ME(swfvideostream, setdimension, NULL, 0)
PHP_ME(swfvideostream, getnumframes, NULL, 0)
}
/* }}} */
-static zend_function_entry swfprebuiltclip_functions[] = {
+static const zend_function_entry swfprebuiltclip_functions[] = {
PHP_ME(swfprebuiltclip, __construct, NULL, 0)
{ NULL, NULL, NULL }
};
/* }}} */
#endif
-static zend_function_entry swfmovie_functions[] = {
+static const zend_function_entry swfmovie_functions[] = {
PHP_ME(swfmovie, __construct, NULL, 0)
PHP_ME(swfmovie, nextFrame, NULL, 0)
PHP_ME(swfmovie, labelFrame, NULL, 0)
}
/* }}} */
-static zend_function_entry swfshape_functions[] = {
+static const zend_function_entry swfshape_functions[] = {
PHP_ME(swfshape, __construct, NULL, 0)
PHP_ME(swfshape, setLine, NULL, 0)
PHP_ME(swfshape, addFill, NULL, 0)
/* }}} */
#endif
-static zend_function_entry swfsprite_functions[] = {
+static const zend_function_entry swfsprite_functions[] = {
PHP_ME(swfsprite, __construct, NULL, 0)
PHP_ME(swfsprite, add, NULL, 0)
PHP_ME(swfsprite, remove, NULL, 0)
}
/* }}} */
-static zend_function_entry swftext_functions[] = {
+static const zend_function_entry swftext_functions[] = {
PHP_ME(swftext, __construct, NULL, 0)
PHP_ME(swftext, setFont, NULL, 0)
PHP_ME(swftext, setHeight, NULL, 0)
/* }}} */
#endif
-static zend_function_entry swftextfield_functions[] = {
+static const zend_function_entry swftextfield_functions[] = {
PHP_ME(swftextfield, __construct, NULL, 0)
PHP_ME(swftextfield, setFont, NULL, 0)
PHP_ME(swftextfield, setBounds, NULL, 0)
/* {{{ msql_functions[]
*/
-zend_function_entry msql_functions[] = {
+const zend_function_entry msql_functions[] = {
PHP_FE(msql_connect, NULL)
PHP_FE(msql_pconnect, NULL)
PHP_FE(msql_close, NULL)
static void _mssql_bind_hash_dtor(void *data);
-zend_function_entry mssql_functions[] = {
+const zend_function_entry mssql_functions[] = {
PHP_FE(mssql_connect, NULL)
PHP_FE(mssql_pconnect, NULL)
PHP_FE(mssql_close, NULL)
/* {{{ mysql_functions[]
*/
-zend_function_entry mysql_functions[] = {
+const zend_function_entry mysql_functions[] = {
PHP_FE(mysql_connect, NULL)
PHP_FE(mysql_pconnect, NULL)
PHP_FE(mysql_close, NULL)
/* {{{ mysqli_module_entry
*/
/* Dependancies */
-static zend_module_dep mysqli_deps[] = {
+static const zend_module_dep mysqli_deps[] = {
#if defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1))
ZEND_MOD_REQUIRED("spl")
#endif
/* {{{ mysqli_driver_methods[]
*/
-zend_function_entry mysqli_driver_methods[] = {
+const zend_function_entry mysqli_driver_methods[] = {
PHP_FALIAS(embedded_server_start, mysqli_embedded_server_start, NULL)
PHP_FALIAS(embedded_server_end, mysqli_embedded_server_end, NULL)
{NULL, NULL, NULL}
/* {{{ mysqli_exception_methods[]
*/
-zend_function_entry mysqli_exception_methods[] = {
+const zend_function_entry mysqli_exception_methods[] = {
{NULL, NULL, NULL}
};
/* }}} */
*
* Every user visible function must have an entry in mysqli_functions[].
*/
-zend_function_entry mysqli_functions[] = {
+const zend_function_entry mysqli_functions[] = {
PHP_FE(mysqli_affected_rows, NULL)
PHP_FE(mysqli_autocommit, NULL)
PHP_FE(mysqli_change_user, NULL)
*
* Every user visible function must have an entry in mysqli_functions[].
*/
-zend_function_entry mysqli_link_methods[] = {
+const zend_function_entry mysqli_link_methods[] = {
PHP_FALIAS(autocommit,mysqli_autocommit,NULL)
PHP_FALIAS(change_user,mysqli_change_user,NULL)
PHP_FALIAS(character_set_name, mysqli_character_set_name,NULL)
*
* Every user visible function must have an entry in mysqli_result_functions[].
*/
-zend_function_entry mysqli_result_methods[] = {
+const zend_function_entry mysqli_result_methods[] = {
PHP_FALIAS(mysqli_result, mysqli_result_construct, NULL)
PHP_FALIAS(close,mysqli_free_result,NULL)
PHP_FALIAS(free,mysqli_free_result,NULL)
*
* Every user visible function must have an entry in mysqli_stmt_functions[].
*/
-zend_function_entry mysqli_stmt_methods[] = {
+const zend_function_entry mysqli_stmt_methods[] = {
PHP_FALIAS(mysqli_stmt, mysqli_stmt_construct, NULL)
PHP_FALIAS(attr_get,mysqli_stmt_attr_get,NULL)
PHP_FALIAS(attr_set,mysqli_stmt_attr_set,NULL)
}
/* }}} */
-zend_function_entry mysqli_warning_methods[] = {
+const zend_function_entry mysqli_warning_methods[] = {
PHP_ME(mysqli_warning, __construct, NULL, ZEND_ACC_PROTECTED)
PHP_ME(mysqli_warning, next, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
#define PHP_MYSQLI_EXPORT(__type) PHP_MYSQLI_API __type
extern zend_module_entry mysqli_module_entry;
-extern zend_function_entry mysqli_functions[];
-extern zend_function_entry mysqli_link_methods[];
-extern zend_function_entry mysqli_stmt_methods[];
-extern zend_function_entry mysqli_result_methods[];
-extern zend_function_entry mysqli_driver_methods[];
-extern zend_function_entry mysqli_warning_methods[];
-extern zend_function_entry mysqli_exception_methods[];
+extern const zend_function_entry mysqli_functions[];
+extern const zend_function_entry mysqli_link_methods[];
+extern const zend_function_entry mysqli_stmt_methods[];
+extern const zend_function_entry mysqli_result_methods[];
+extern const zend_function_entry mysqli_driver_methods[];
+extern const zend_function_entry mysqli_warning_methods[];
+extern const zend_function_entry mysqli_exception_methods[];
extern mysqli_property_entry mysqli_link_property_entries[];
extern mysqli_property_entry mysqli_result_property_entries[];
*
* Every user visible function must have an entry in ncurses_functions[].
*/
-zend_function_entry ncurses_functions[] = {
+const zend_function_entry ncurses_functions[] = {
PHP_FE(ncurses_addch, NULL)
#ifdef HAVE_NCURSES_COLOR_SET
PHP_FE(ncurses_color_set, NULL)
extern zend_module_entry ncurses_module_entry;
#define phpext_ncurses_ptr &ncurses_module_entry
-extern zend_function_entry ncurses_functions[];
+extern const zend_function_entry ncurses_functions[];
#include "php_ncurses_fe.h"
#ifdef PHP_WIN32
/* {{{ extension definition structures
*/
-static zend_function_entry php_oci_functions[] = {
+static const zend_function_entry php_oci_functions[] = {
PHP_FE(oci_define_by_name, oci_third_arg_force_ref)
PHP_FE(oci_bind_by_name, oci_third_arg_force_ref)
PHP_FE(oci_bind_array_by_name, oci_third_arg_force_ref)
{NULL,NULL,NULL}
};
-static zend_function_entry php_oci_lob_class_functions[] = {
+static const zend_function_entry php_oci_lob_class_functions[] = {
PHP_FALIAS(load, oci_lob_load, NULL)
PHP_FALIAS(tell, oci_lob_tell, NULL)
PHP_FALIAS(truncate, oci_lob_truncate, NULL)
};
#ifdef PHP_OCI8_HAVE_COLLECTIONS
-static zend_function_entry php_oci_coll_class_functions[] = {
+static const zend_function_entry php_oci_coll_class_functions[] = {
PHP_FALIAS(append, oci_collection_append, NULL)
PHP_FALIAS(getelem, oci_collection_element_get, NULL)
PHP_FALIAS(assignelem, oci_collection_element_assign, NULL)
#include "ext/standard/info.h"
#include "php_ini.h"
-zend_function_entry birdstep_functions[] = {
+const zend_function_entry birdstep_functions[] = {
PHP_FE(birdstep_connect, NULL)
PHP_FE(birdstep_close, NULL)
PHP_FE(birdstep_exec, NULL)
/* {{{ odbc_functions[]
*/
-zend_function_entry odbc_functions[] = {
+const zend_function_entry odbc_functions[] = {
PHP_FE(odbc_autocommit, NULL)
PHP_FE(odbc_binmode, NULL)
PHP_FE(odbc_close, NULL)
/* {{{ openssl_functions[]
*/
-zend_function_entry openssl_functions[] = {
+const zend_function_entry openssl_functions[] = {
/* public/private key functions */
PHP_FE(openssl_pkey_free, NULL)
PHP_FE(openssl_pkey_new, NULL)
ZEND_DECLARE_MODULE_GLOBALS(pcntl)
static PHP_GINIT_FUNCTION(pcntl);
-zend_function_entry pcntl_functions[] = {
+const zend_function_entry pcntl_functions[] = {
PHP_FE(pcntl_fork, NULL)
PHP_FE(pcntl_waitpid, second_arg_force_ref)
PHP_FE(pcntl_wait, first_arg_force_ref)
/* {{{ module definition structures */
-zend_function_entry pcre_functions[] = {
+const zend_function_entry pcre_functions[] = {
PHP_FE(preg_match, third_arg_force_ref)
PHP_FE(preg_match_all, third_arg_force_ref)
PHP_FE(preg_replace, fifth_arg_force_ref)
/* }}} */
/* {{{ pdo_functions[] */
-zend_function_entry pdo_functions[] = {
+const zend_function_entry pdo_functions[] = {
PHP_FE(pdo_drivers, NULL)
{NULL, NULL, NULL}
};
/* {{{ pdo_functions[] */
#if ZEND_MODULE_API_NO >= 20050922
-static zend_module_dep pdo_deps[] = {
+static const zend_module_dep pdo_deps[] = {
#ifdef HAVE_SPL
ZEND_MOD_REQUIRED("spl")
#endif
ZEND_END_ARG_INFO()
/* }}} */
-zend_function_entry pdo_dbh_functions[] = {
+const zend_function_entry pdo_dbh_functions[] = {
ZEND_MALIAS(PDO, __construct, dbh_constructor, arginfo_pdo___construct, ZEND_ACC_PUBLIC)
PHP_ME(PDO, prepare, arginfo_pdo_prepare, ZEND_ACC_PUBLIC)
PHP_ME(PDO, beginTransaction, NULL, ZEND_ACC_PUBLIC)
/* {{{ overloaded object handlers for PDO class */
int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
{
- zend_function_entry *funcs;
+ const zend_function_entry *funcs;
zend_function func;
zend_internal_function *ifunc = (zend_internal_function*)&func;
int namelen;
while (funcs->fname) {
ifunc->type = ZEND_INTERNAL_FUNCTION;
ifunc->handler = funcs->handler;
- ifunc->function_name = funcs->fname;
+ ifunc->function_name = (char*)funcs->fname;
ifunc->scope = dbh->ce;
ifunc->prototype = NULL;
if (funcs->arg_info) {
- ifunc->arg_info = funcs->arg_info + 1;
+ ifunc->arg_info = (zend_arg_info*)funcs->arg_info + 1;
ifunc->num_args = funcs->num_args;
if (funcs->arg_info[0].required_num_args == -1) {
ifunc->required_num_args = funcs->num_args;
}
/* }}} */
-zend_function_entry pdo_dbstmt_functions[] = {
+const zend_function_entry pdo_dbstmt_functions[] = {
PHP_ME(PDOStatement, execute, arginfo_pdostatement_execute, ZEND_ACC_PUBLIC)
PHP_ME(PDOStatement, fetch, arginfo_pdostatement_fetch, ZEND_ACC_PUBLIC)
PHP_ME(PDOStatement, bindParam, arginfo_pdostatement_bindparam, ZEND_ACC_PUBLIC)
/* {{{ overloaded handlers for PDORow class (used by PDO_FETCH_LAZY) */
-zend_function_entry pdo_row_functions[] = {
+const zend_function_entry pdo_row_functions[] = {
{NULL, NULL, NULL}
};
PDO_DBH_DRIVER_METHOD_KIND__MAX
};
-typedef zend_function_entry *(*pdo_dbh_get_driver_methods_func)(pdo_dbh_t *dbh, int kind TSRMLS_DC);
+typedef const zend_function_entry *(*pdo_dbh_get_driver_methods_func)(pdo_dbh_t *dbh, int kind TSRMLS_DC);
struct pdo_dbh_methods {
pdo_dbh_close_func closer;
void pdo_stmt_init(TSRMLS_D);
extern zend_object_value pdo_dbh_new(zend_class_entry *ce TSRMLS_DC);
-extern zend_function_entry pdo_dbh_functions[];
+extern const zend_function_entry pdo_dbh_functions[];
extern zend_class_entry *pdo_dbh_ce;
extern ZEND_RSRC_DTOR_FUNC(php_pdo_pdbh_dtor);
extern zend_object_value pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC);
-extern zend_function_entry pdo_dbstmt_functions[];
+extern const zend_function_entry pdo_dbstmt_functions[];
extern zend_class_entry *pdo_dbstmt_ce;
void pdo_dbstmt_free_storage(pdo_stmt_t *stmt TSRMLS_DC);
zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, int skip_first_arg);
extern zend_object_value pdo_row_new(zend_class_entry *ce TSRMLS_DC);
-extern zend_function_entry pdo_row_functions[];
+extern const zend_function_entry pdo_row_functions[];
extern zend_class_entry *pdo_row_ce;
void pdo_row_free_storage(pdo_stmt_t *stmt TSRMLS_DC);
extern zend_object_handlers pdo_row_object_handlers;
ZEND_DECLARE_MODULE_GLOBALS(dblib)
static PHP_GINIT_FUNCTION(dblib);
-zend_function_entry pdo_dblib_functions[] = {
+const zend_function_entry pdo_dblib_functions[] = {
{NULL, NULL, NULL}
};
#if ZEND_MODULE_API_NO >= 20050922
-static zend_module_dep pdo_dblib_deps[] = {
+static const zend_module_dep pdo_dblib_deps[] = {
ZEND_MOD_REQUIRED("pdo")
{NULL, NULL, NULL}
};
#include "php_pdo_firebird.h"
#include "php_pdo_firebird_int.h"
-zend_function_entry pdo_firebird_functions[] = { /* {{{ */
+const zend_function_entry pdo_firebird_functions[] = { /* {{{ */
{NULL, NULL, NULL}
};
/* }}} */
#include "php_pdo_mysql_int.h"
/* {{{ pdo_mysql_functions[] */
-zend_function_entry pdo_mysql_functions[] = {
+const zend_function_entry pdo_mysql_functions[] = {
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ pdo_mysql_functions[] */
#if ZEND_MODULE_API_NO >= 20050922
-static zend_module_dep pdo_mysql_deps[] = {
+static const zend_module_dep pdo_mysql_deps[] = {
ZEND_MOD_REQUIRED("pdo")
{NULL, NULL, NULL}
};
#include "php_pdo_oci_int.h"
/* {{{ pdo_oci_functions[] */
-zend_function_entry pdo_oci_functions[] = {
+const zend_function_entry pdo_oci_functions[] = {
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ pdo_oci_module_entry */
#if ZEND_MODULE_API_NO >= 20050922
-static zend_module_dep pdo_oci_deps[] = {
+static const zend_module_dep pdo_oci_deps[] = {
ZEND_MOD_REQUIRED("pdo")
{NULL, NULL, NULL}
};
#include "php_pdo_odbc_int.h"
/* {{{ pdo_odbc_functions[] */
-function_entry pdo_odbc_functions[] = {
+const function_entry pdo_odbc_functions[] = {
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ pdo_odbc_deps[] */
#if ZEND_MODULE_API_NO >= 20050922
-static zend_module_dep pdo_odbc_deps[] = {
+static const zend_module_dep pdo_odbc_deps[] = {
ZEND_MOD_REQUIRED("pdo")
{NULL, NULL, NULL}
};
#endif
/* {{{ pdo_pgsql_functions[] */
-zend_function_entry pdo_pgsql_functions[] = {
+const zend_function_entry pdo_pgsql_functions[] = {
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ pdo_sqlite_deps
*/
#if ZEND_MODULE_API_NO >= 20050922
-static zend_module_dep pdo_pgsql_deps[] = {
+static const zend_module_dep pdo_pgsql_deps[] = {
ZEND_MOD_REQUIRED("pdo")
{NULL, NULL, NULL}
};
/* }}} */
-static zend_function_entry dbh_methods[] = {
+static const zend_function_entry dbh_methods[] = {
PHP_ME(PDO, pgsqlLOBCreate, NULL, ZEND_ACC_PUBLIC)
PHP_ME(PDO, pgsqlLOBOpen, NULL, ZEND_ACC_PUBLIC)
PHP_ME(PDO, pgsqlLOBUnlink, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
-static zend_function_entry *pdo_pgsql_get_driver_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
+static const zend_function_entry *pdo_pgsql_get_driver_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
{
switch (kind) {
case PDO_DBH_DRIVER_METHOD_KIND_DBH:
#define PHP_PDO_SQLITE_MODULE_VERSION "1.0.1"
/* {{{ pdo_sqlite_functions[] */
-zend_function_entry pdo_sqlite_functions[] = {
+const zend_function_entry pdo_sqlite_functions[] = {
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ pdo_sqlite_deps
*/
#if ZEND_MODULE_API_NO >= 20050922
-static zend_module_dep pdo_sqlite_deps[] = {
+static const zend_module_dep pdo_sqlite_deps[] = {
ZEND_MOD_REQUIRED("pdo")
{NULL, NULL, NULL}
};
RETURN_FALSE;
}
/* }}} */
-static zend_function_entry dbh_methods[] = {
+static const zend_function_entry dbh_methods[] = {
PHP_ME(SQLite, sqliteCreateFunction, NULL, ZEND_ACC_PUBLIC)
PHP_ME(SQLite, sqliteCreateAggregate, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
-static zend_function_entry *get_driver_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
+static const zend_function_entry *get_driver_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
{
switch (kind) {
case PDO_DBH_DRIVER_METHOD_KIND_DBH:
/* {{{ pgsql_functions[]
*/
-zend_function_entry pgsql_functions[] = {
+const zend_function_entry pgsql_functions[] = {
/* connection functions */
PHP_FE(pg_connect, NULL)
PHP_FE(pg_pconnect, NULL)
/* {{{ posix_functions[]
*/
-zend_function_entry posix_functions[] = {
+const zend_function_entry posix_functions[] = {
/* POSIX.1, 3.3 */
PHP_FE(posix_kill, NULL)
/* {{{ pspell_functions[]
*/
-static zend_function_entry pspell_functions[] = {
+static const zend_function_entry pspell_functions[] = {
PHP_FE(pspell_new, NULL)
PHP_FE(pspell_new_personal, NULL)
PHP_FE(pspell_new_config, NULL)
/* }}} */
/* {{{ module stuff */
-static zend_function_entry php_readline_functions[] = {
+static const zend_function_entry php_readline_functions[] = {
PHP_FE(readline, NULL)
PHP_FE(readline_info, NULL)
PHP_FE(readline_add_history, NULL)
static PHP_GINIT_FUNCTION(recode);
/* {{{ module stuff */
-static zend_function_entry php_recode_functions[] = {
+static const zend_function_entry php_recode_functions[] = {
PHP_FE(recode_string, NULL)
PHP_FE(recode_file, NULL)
PHP_FALIAS(recode, recode_string, NULL)
(module->version == NO_VERSION_YET) ? "<no_version>" : module->version);
if (module->deps) {
- zend_module_dep* dep = module->deps;
+ const zend_module_dep* dep = module->deps;
string_printf(str, "\n - Dependencies {\n");
if (module->functions && module->functions->fname) {
zend_function *fptr;
- zend_function_entry *func = module->functions;
+ const zend_function_entry *func = module->functions;
string_printf(str, "\n - Functions {\n");
/* }}} */
/* {{{ reflection_extension_factory */
-static void reflection_extension_factory(zval *object, char *name_str TSRMLS_DC)
+static void reflection_extension_factory(zval *object, const char *name_str TSRMLS_DC)
{
reflection_object *intern;
zval *name;
if (module->functions) {
zval *function;
zend_function *fptr;
- zend_function_entry *func = module->functions;
+ const zend_function_entry *func = module->functions;
/* Is there a better way of doing this? */
while (func->fname) {
{
reflection_object *intern;
zend_module_entry *module;
- zend_module_dep *dep;
+ const zend_module_dep *dep;
METHOD_NOTSTATIC_NUMPARAMS(reflection_extension_ptr, 0);
GET_REFLECTION_OBJECT_PTR(module);
/* }}} */
/* {{{ method tables */
-static zend_function_entry reflection_exception_functions[] = {
+static const zend_function_entry reflection_exception_functions[] = {
{NULL, NULL, NULL}
};
ZEND_ARG_INFO(0, return)
ZEND_END_ARG_INFO()
-static zend_function_entry reflection_functions[] = {
+static const zend_function_entry reflection_functions[] = {
ZEND_ME(reflection, getModifierNames, arginfo_reflection_getModifierNames, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
ZEND_ME(reflection, export, arginfo_reflection_export, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
{NULL, NULL, NULL}
};
-static zend_function_entry reflector_functions[] = {
+static const zend_function_entry reflector_functions[] = {
ZEND_FENTRY(export, NULL, NULL, ZEND_ACC_STATIC|ZEND_ACC_ABSTRACT|ZEND_ACC_PUBLIC)
ZEND_ABSTRACT_ME(reflector, __toString, NULL)
{NULL, NULL, NULL}
ZEND_ARG_ARRAY_INFO(0, args, 0)
ZEND_END_ARG_INFO()
-static zend_function_entry reflection_function_abstract_functions[] = {
+static const zend_function_entry reflection_function_abstract_functions[] = {
ZEND_ME(reflection, __clone, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
PHP_ABSTRACT_ME(reflection_function, __toString, NULL)
ZEND_ME(reflection_function, isInternal, NULL, 0)
{NULL, NULL, NULL}
};
-static zend_function_entry reflection_function_functions[] = {
+static const zend_function_entry reflection_function_functions[] = {
ZEND_ME(reflection_function, __construct, arginfo_reflection_function___construct, 0)
ZEND_ME(reflection_function, __toString, NULL, 0)
ZEND_ME(reflection_function, export, arginfo_reflection_function_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
ZEND_ARG_ARRAY_INFO(0, args, 0)
ZEND_END_ARG_INFO()
-static zend_function_entry reflection_method_functions[] = {
+static const zend_function_entry reflection_method_functions[] = {
ZEND_ME(reflection_method, export, arginfo_reflection_method_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
ZEND_ME(reflection_method, __construct, arginfo_reflection_method___construct, 0)
ZEND_ME(reflection_method, __toString, NULL, 0)
ZEND_ARG_INFO(0, interface)
ZEND_END_ARG_INFO()
-static zend_function_entry reflection_class_functions[] = {
+static const zend_function_entry reflection_class_functions[] = {
ZEND_ME(reflection, __clone, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
ZEND_ME(reflection_class, export, arginfo_reflection_class_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
ZEND_ME(reflection_class, __construct, arginfo_reflection_class___construct, 0)
ZEND_ARG_INFO(0, argument)
ZEND_END_ARG_INFO()
-static zend_function_entry reflection_object_functions[] = {
+static const zend_function_entry reflection_object_functions[] = {
ZEND_ME(reflection_object, export, arginfo_reflection_object_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
ZEND_ME(reflection_object, __construct, arginfo_reflection_object___construct, 0)
{NULL, NULL, NULL}
ZEND_ARG_INFO(0, value)
ZEND_END_ARG_INFO()
-static zend_function_entry reflection_property_functions[] = {
+static const zend_function_entry reflection_property_functions[] = {
ZEND_ME(reflection, __clone, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
ZEND_ME(reflection_property, export, arginfo_reflection_property_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
ZEND_ME(reflection_property, __construct, arginfo_reflection_property___construct, 0)
ZEND_ARG_INFO(0, parameter)
ZEND_END_ARG_INFO()
-static zend_function_entry reflection_parameter_functions[] = {
+static const zend_function_entry reflection_parameter_functions[] = {
ZEND_ME(reflection, __clone, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
ZEND_ME(reflection_parameter, export, arginfo_reflection_parameter_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
ZEND_ME(reflection_parameter, __construct, arginfo_reflection_parameter___construct, 0)
ZEND_ARG_INFO(0, name)
ZEND_END_ARG_INFO()
-static zend_function_entry reflection_extension_functions[] = {
+static const zend_function_entry reflection_extension_functions[] = {
ZEND_ME(reflection, __clone, NULL, ZEND_ACC_PRIVATE|ZEND_ACC_FINAL)
ZEND_ME(reflection_extension, export, arginfo_reflection_extension_export, ZEND_ACC_STATIC|ZEND_ACC_PUBLIC)
ZEND_ME(reflection_extension, __construct, arginfo_reflection_extension___construct, 0)
};
/* }}} */
-zend_function_entry reflection_ext_functions[] = { /* {{{ */
+const zend_function_entry reflection_ext_functions[] = { /* {{{ */
{NULL, NULL, NULL}
}; /* }}} */
/* {{{ session_functions[]
*/
-zend_function_entry session_functions[] = {
+const zend_function_entry session_functions[] = {
PHP_FE(session_name, NULL)
PHP_FE(session_module_name, NULL)
PHP_FE(session_save_path, NULL)
/* {{{ shmop_functions[]
*/
-zend_function_entry shmop_functions[] = {
+const zend_function_entry shmop_functions[] = {
PHP_FE(shmop_open, NULL)
PHP_FE(shmop_read, NULL)
PHP_FE(shmop_close, NULL)
}
/* }}} */
-zend_function_entry simplexml_functions[] = {
+const zend_function_entry simplexml_functions[] = {
PHP_FE(simplexml_load_file, NULL)
PHP_FE(simplexml_load_string, NULL)
PHP_FE(simplexml_import_dom, NULL)
{NULL, NULL, NULL}
};
-static zend_module_dep simplexml_deps[] = {
+static const zend_module_dep simplexml_deps[] = {
ZEND_MOD_REQUIRED("libxml")
{NULL, NULL, NULL}
};
/* the method table */
/* each method can have its own parameters and visibility */
-static zend_function_entry sxe_functions[] = {
+static const zend_function_entry sxe_functions[] = {
SXE_ME(__construct, NULL, ZEND_ACC_PUBLIC|ZEND_ACC_FINAL) /* must be called */
SXE_ME(asXML, NULL, ZEND_ACC_PUBLIC)
SXE_MALIAS(saveXML, asXML, NULL, ZEND_ACC_PUBLIC)
*
* Every user visible function must have an entry in extname_functions[].
*/
-zend_function_entry extname_functions[] = {
+const zend_function_entry extname_functions[] = {
PHP_FE(confirm_extname_compiled, NULL) /* For testing, remove later. */
/* __function_entries_here__ */
{NULL, NULL, NULL} /* Must be the last line in extname_functions[] */
/* {{{ snmp_functions[]
*/
-zend_function_entry snmp_functions[] = {
+const zend_function_entry snmp_functions[] = {
PHP_FE(snmpget, NULL)
PHP_FE(snmpgetnext, NULL)
PHP_FE(snmpwalk, NULL)
/* {{{ snmp_functions[]
*/
-zend_function_entry snmp_functions[] = {
+const zend_function_entry snmp_functions[] = {
{"snmpget", php3_snmpget, NULL},
{"snmpwalk", php3_snmpwalk, NULL},
{NULL,NULL,NULL}
#define SOAP_CTOR(class_name, func_name, arginfo, flags) PHP_ME(class_name, func_name, arginfo, flags)
-static zend_function_entry soap_functions[] = {
+static const zend_function_entry soap_functions[] = {
PHP_FE(use_soap_error_handler, NULL)
PHP_FE(is_soap_fault, NULL)
{NULL, NULL, NULL}
};
-static zend_function_entry soap_fault_functions[] = {
+static const zend_function_entry soap_fault_functions[] = {
SOAP_CTOR(SoapFault, SoapFault, NULL, 0)
#ifdef ZEND_ENGINE_2
PHP_ME(SoapFault, __toString, NULL, 0)
{NULL, NULL, NULL}
};
-static zend_function_entry soap_server_functions[] = {
+static const zend_function_entry soap_server_functions[] = {
SOAP_CTOR(SoapServer, SoapServer, NULL, 0)
PHP_ME(SoapServer, setPersistence, NULL, 0)
PHP_ME(SoapServer, setClass, NULL, 0)
unsigned char __soap_call_args[] = { 5, BYREF_NONE, BYREF_NONE, BYREF_NONE, BYREF_NONE, BYREF_FORCE };
#endif
-static zend_function_entry soap_client_functions[] = {
+static const zend_function_entry soap_client_functions[] = {
SOAP_CTOR(SoapClient, SoapClient, NULL, 0)
PHP_ME(SoapClient, __call, __call_args, 0)
ZEND_NAMED_ME(__soapCall, ZEND_MN(SoapClient___call), __soap_call_args, 0)
{NULL, NULL, NULL}
};
-static zend_function_entry soap_var_functions[] = {
+static const zend_function_entry soap_var_functions[] = {
SOAP_CTOR(SoapVar, SoapVar, NULL, 0)
{NULL, NULL, NULL}
};
-static zend_function_entry soap_param_functions[] = {
+static const zend_function_entry soap_param_functions[] = {
SOAP_CTOR(SoapParam, SoapParam, NULL, 0)
{NULL, NULL, NULL}
};
-static zend_function_entry soap_header_functions[] = {
+static const zend_function_entry soap_header_functions[] = {
SOAP_CTOR(SoapHeader, SoapHeader, NULL, 0)
{NULL, NULL, NULL}
};
/* {{{ sockets_functions[]
*/
-zend_function_entry sockets_functions[] = {
+const zend_function_entry sockets_functions[] = {
PHP_FE(socket_select, first_through_third_args_force_ref)
PHP_FE(socket_create, NULL)
PHP_FE(socket_create_listen, NULL)
/* {{{ spl_functions_none
*/
-zend_function_entry spl_functions_none[] = {
+const zend_function_entry spl_functions_none[] = {
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ spl_functions
*/
-zend_function_entry spl_functions[] = {
+const zend_function_entry spl_functions[] = {
PHP_FE(spl_classes, NULL)
PHP_FE(spl_autoload, NULL)
PHP_FE(spl_autoload_extensions, NULL)
} /* }}} */
#ifdef HAVE_SIMPLEXML
-static zend_module_dep spl_deps[] = {
+static const zend_module_dep spl_deps[] = {
ZEND_MOD_REQUIRED("libxml")
ZEND_MOD_REQUIRED("simplexml")
{NULL, NULL, NULL}
ZEND_ARG_INFO(0, cmp_function )
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_ArrayObject[] = {
+static const zend_function_entry spl_funcs_ArrayObject[] = {
SPL_ME(Array, __construct, arginfo_array___construct, ZEND_ACC_PUBLIC)
SPL_ME(Array, offsetExists, arginfo_array_offsetGet, ZEND_ACC_PUBLIC)
SPL_ME(Array, offsetGet, arginfo_array_offsetGet, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
-static zend_function_entry spl_funcs_ArrayIterator[] = {
+static const zend_function_entry spl_funcs_ArrayIterator[] = {
SPL_ME(Array, __construct, arginfo_array___construct, ZEND_ACC_PUBLIC)
SPL_ME(Array, offsetExists, arginfo_array_offsetGet, ZEND_ACC_PUBLIC)
SPL_ME(Array, offsetGet, arginfo_array_offsetGet, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
-static zend_function_entry spl_funcs_RecursiveArrayIterator[] = {
+static const zend_function_entry spl_funcs_RecursiveArrayIterator[] = {
SPL_ME(Array, hasChildren, NULL, ZEND_ACC_PUBLIC)
SPL_ME(Array, getChildren, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
/* the method table */
/* each method can have its own parameters and visibility */
-static zend_function_entry spl_SplFileInfo_functions[] = {
+static const zend_function_entry spl_SplFileInfo_functions[] = {
SPL_ME(SplFileInfo, __construct, arginfo_info___construct, ZEND_ACC_PUBLIC)
SPL_ME(SplFileInfo, getPath, NULL, ZEND_ACC_PUBLIC)
SPL_ME(SplFileInfo, getFilename, NULL, ZEND_ACC_PUBLIC)
/* the method table */
/* each method can have its own parameters and visibility */
-static zend_function_entry spl_DirectoryIterator_functions[] = {
+static const zend_function_entry spl_DirectoryIterator_functions[] = {
SPL_ME(DirectoryIterator, __construct, arginfo_dir___construct, ZEND_ACC_PUBLIC)
SPL_ME(DirectoryIterator, getFilename, NULL, ZEND_ACC_PUBLIC)
SPL_ME(DirectoryIterator, getBasename, arginfo_optinalSuffix, ZEND_ACC_PUBLIC)
ZEND_ARG_INFO(0, allow_links)
ZEND_END_ARG_INFO()
-static zend_function_entry spl_RecursiveDirectoryIterator_functions[] = {
+static const zend_function_entry spl_RecursiveDirectoryIterator_functions[] = {
SPL_ME(RecursiveDirectoryIterator, __construct, arginfo_r_dir___construct, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveDirectoryIterator, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveDirectoryIterator, next, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_INFO(0, line_pos)
ZEND_END_ARG_INFO()
-static zend_function_entry spl_SplFileObject_functions[] = {
+static const zend_function_entry spl_SplFileObject_functions[] = {
SPL_ME(SplFileObject, __construct, arginfo_file_object___construct, ZEND_ACC_PUBLIC)
SPL_ME(SplFileObject, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(SplFileObject, eof, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_INFO(0, max_memory)
ZEND_END_ARG_INFO()
-static zend_function_entry spl_SplTempFileObject_functions[] = {
+static const zend_function_entry spl_SplTempFileObject_functions[] = {
SPL_ME(SplTempFileObject, __construct, arginfo_temp_file_object___construct, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
/* }}} */
/* {{{ spl_register_interface */
-void spl_register_interface(zend_class_entry ** ppce, char * class_name, zend_function_entry * functions TSRMLS_DC)
+void spl_register_interface(zend_class_entry ** ppce, char * class_name, const zend_function_entry * functions TSRMLS_DC)
{
zend_class_entry ce;
/* }}} */
/* {{{ spl_register_std_class */
-PHPAPI void spl_register_std_class(zend_class_entry ** ppce, char * class_name, void * obj_ctor, zend_function_entry * function_list TSRMLS_DC)
+PHPAPI void spl_register_std_class(zend_class_entry ** ppce, char * class_name, void * obj_ctor, const zend_function_entry * function_list TSRMLS_DC)
{
zend_class_entry ce;
/* }}} */
/* {{{ spl_register_sub_class */
-PHPAPI void spl_register_sub_class(zend_class_entry ** ppce, zend_class_entry * parent_ce, char * class_name, void *obj_ctor, zend_function_entry * function_list TSRMLS_DC)
+PHPAPI void spl_register_sub_class(zend_class_entry ** ppce, zend_class_entry * parent_ce, char * class_name, void *obj_ctor, const zend_function_entry * function_list TSRMLS_DC)
{
zend_class_entry ce;
/* }}} */
/* {{{ spl_register_functions */
-void spl_register_functions(zend_class_entry * class_entry, zend_function_entry * function_list TSRMLS_DC)
+void spl_register_functions(zend_class_entry * class_entry, const zend_function_entry * function_list TSRMLS_DC)
{
zend_register_functions(class_entry, function_list, &class_entry->function_table, MODULE_PERSISTENT TSRMLS_CC);
}
void spl_destroy_class(zend_class_entry ** ppce);
-void spl_register_std_class(zend_class_entry ** ppce, char * class_name, create_object_func_t ctor, zend_function_entry * function_list TSRMLS_DC);
-void spl_register_sub_class(zend_class_entry ** ppce, zend_class_entry * parent_ce, char * class_name, create_object_func_t ctor, zend_function_entry * function_list TSRMLS_DC);
+void spl_register_std_class(zend_class_entry ** ppce, char * class_name, create_object_func_t ctor, const zend_function_entry * function_list TSRMLS_DC);
+void spl_register_sub_class(zend_class_entry ** ppce, zend_class_entry * parent_ce, char * class_name, create_object_func_t ctor, const zend_function_entry * function_list TSRMLS_DC);
-void spl_register_interface(zend_class_entry ** ppce, char * class_name, zend_function_entry *functions TSRMLS_DC);
+void spl_register_interface(zend_class_entry ** ppce, char * class_name, const zend_function_entry *functions TSRMLS_DC);
void spl_register_parent_ce(zend_class_entry * class_entry, zend_class_entry * parent_class TSRMLS_DC);
-void spl_register_functions(zend_class_entry * class_entry, zend_function_entry * function_list TSRMLS_DC);
+void spl_register_functions(zend_class_entry * class_entry, const zend_function_entry * function_list TSRMLS_DC);
void spl_register_property( zend_class_entry * class_entry, char *prop_name, int prop_name_len, int prop_flags TSRMLS_DC);
/* sub: whether to allow subclasses/interfaces
PHPAPI zend_class_entry *spl_ce_RecursiveRegexIterator;
PHPAPI zend_class_entry *spl_ce_Countable;
-zend_function_entry spl_funcs_RecursiveIterator[] = {
+const zend_function_entry spl_funcs_RecursiveIterator[] = {
SPL_ABSTRACT_ME(RecursiveIterator, hasChildren, NULL)
SPL_ABSTRACT_ME(RecursiveIterator, getChildren, NULL)
{NULL, NULL, NULL}
ZEND_ARG_INFO(0, max_depth)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_RecursiveIteratorIterator[] = {
+static const zend_function_entry spl_funcs_RecursiveIteratorIterator[] = {
SPL_ME(RecursiveIteratorIterator, __construct, arginfo_recursive_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveIteratorIterator, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveIteratorIterator, valid, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_FilterIterator[] = {
+static const zend_function_entry spl_funcs_FilterIterator[] = {
SPL_ME(FilterIterator, __construct, arginfo_filter_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(FilterIterator, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(dual_it, valid, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_OBJ_INFO(0, iterator, RecursiveIterator, 0)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_RecursiveFilterIterator[] = {
+static const zend_function_entry spl_funcs_RecursiveFilterIterator[] = {
SPL_ME(RecursiveFilterIterator, __construct, arginfo_parent_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveFilterIterator, hasChildren, NULL, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveFilterIterator, getChildren, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
-static zend_function_entry spl_funcs_ParentIterator[] = {
+static const zend_function_entry spl_funcs_ParentIterator[] = {
SPL_ME(ParentIterator, __construct, arginfo_parent_it___construct, ZEND_ACC_PUBLIC)
SPL_MA(ParentIterator, accept, RecursiveFilterIterator, hasChildren, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
ZEND_ARG_INFO(0, preg_flags)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_RegexIterator[] = {
+static const zend_function_entry spl_funcs_RegexIterator[] = {
SPL_ME(RegexIterator, __construct, arginfo_regex_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(RegexIterator, accept, NULL, ZEND_ACC_PUBLIC)
SPL_ME(RegexIterator, getMode, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_INFO(0, preg_flags)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_RecursiveRegexIterator[] = {
+static const zend_function_entry spl_funcs_RecursiveRegexIterator[] = {
SPL_ME(RecursiveRegexIterator, __construct, arginfo_rec_regex_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveFilterIterator, hasChildren, NULL, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveRegexIterator, getChildren, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_INFO(0, position)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_SeekableIterator[] = {
+static const zend_function_entry spl_funcs_SeekableIterator[] = {
SPL_ABSTRACT_ME(SeekableIterator, seek, arginfo_seekable_it_seek)
{NULL, NULL, NULL}
};
ZEND_ARG_INFO(0, position)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_LimitIterator[] = {
+static const zend_function_entry spl_funcs_LimitIterator[] = {
SPL_ME(LimitIterator, __construct, arginfo_limit_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(LimitIterator, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(LimitIterator, valid, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_INFO(0, newval)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_CachingIterator[] = {
+static const zend_function_entry spl_funcs_CachingIterator[] = {
SPL_ME(CachingIterator, __construct, arginfo_caching_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(CachingIterator, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(CachingIterator, valid, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_INFO(0, flags)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_RecursiveCachingIterator[] = {
+static const zend_function_entry spl_funcs_RecursiveCachingIterator[] = {
SPL_ME(RecursiveCachingIterator, __construct, arginfo_caching_rec_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveCachingIterator, hasChildren, NULL, ZEND_ACC_PUBLIC)
SPL_ME(RecursiveCachingIterator, getChildren, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_OBJ_INFO(0, iterator, Traversable, 0)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_IteratorIterator[] = {
+static const zend_function_entry spl_funcs_IteratorIterator[] = {
SPL_ME(IteratorIterator, __construct, arginfo_iterator_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(dual_it, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(dual_it, valid, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_NoRewindIterator[] = {
+static const zend_function_entry spl_funcs_NoRewindIterator[] = {
SPL_ME(NoRewindIterator, __construct, arginfo_norewind_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(NoRewindIterator, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(NoRewindIterator, valid, NULL, ZEND_ACC_PUBLIC)
}
} /* }}} */
-static zend_function_entry spl_funcs_InfiniteIterator[] = {
+static const zend_function_entry spl_funcs_InfiniteIterator[] = {
SPL_ME(InfiniteIterator, __construct, arginfo_norewind_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(InfiniteIterator, next, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
{
} /* }}} */
-static zend_function_entry spl_funcs_EmptyIterator[] = {
+static const zend_function_entry spl_funcs_EmptyIterator[] = {
SPL_ME(EmptyIterator, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(EmptyIterator, valid, NULL, ZEND_ACC_PUBLIC)
SPL_ME(EmptyIterator, key, NULL, ZEND_ACC_PUBLIC)
ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_AppendIterator[] = {
+static const zend_function_entry spl_funcs_AppendIterator[] = {
SPL_ME(AppendIterator, __construct, NULL, ZEND_ACC_PUBLIC)
SPL_ME(AppendIterator, append, arginfo_append_it_append, ZEND_ACC_PUBLIC)
SPL_ME(AppendIterator, rewind, NULL, ZEND_ACC_PUBLIC)
}
/* }}} */
-static zend_function_entry spl_funcs_OuterIterator[] = {
+static const zend_function_entry spl_funcs_OuterIterator[] = {
SPL_ABSTRACT_ME(OuterIterator, getInnerIterator, NULL)
{NULL, NULL, NULL}
};
-static zend_function_entry spl_funcs_Countable[] = {
+static const zend_function_entry spl_funcs_Countable[] = {
SPL_ABSTRACT_ME(Countable, count, NULL)
{NULL, NULL, NULL}
};
ZEND_ARG_OBJ_INFO(0, SplSubject, SplSubject, 0)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_SplObserver[] = {
+static const zend_function_entry spl_funcs_SplObserver[] = {
SPL_ABSTRACT_ME(SplObserver, update, arginfo_SplObserver_update)
{NULL, NULL, NULL}
};
ZEND_ARG_OBJ_INFO(0, ignore, SplObserver, 1)
ZEND_END_ARG_INFO();*/
-static zend_function_entry spl_funcs_SplSubject[] = {
+static const zend_function_entry spl_funcs_SplSubject[] = {
SPL_ABSTRACT_ME(SplSubject, attach, arginfo_SplSubject_attach)
SPL_ABSTRACT_ME(SplSubject, detach, arginfo_SplSubject_attach)
SPL_ABSTRACT_ME(SplSubject, notify, NULL)
ZEND_ARG_INFO(0, serialized)
ZEND_END_ARG_INFO();
-static zend_function_entry spl_funcs_SplObjectStorage[] = {
+static const zend_function_entry spl_funcs_SplObjectStorage[] = {
SPL_ME(SplObjectStorage, attach, arginfo_Object, 0)
SPL_ME(SplObjectStorage, detach, arginfo_Object, 0)
SPL_ME(SplObjectStorage, contains, arginfo_Object, 0)
RETURN_LONG(count);
}
-static zend_function_entry spl_funcs_SimpleXMLIterator[] = {
+static const zend_function_entry spl_funcs_SimpleXMLIterator[] = {
SPL_ME(SimpleXMLIterator, rewind, NULL, ZEND_ACC_PUBLIC)
SPL_ME(SimpleXMLIterator, valid, NULL, ZEND_ACC_PUBLIC)
SPL_ME(SimpleXMLIterator, current, NULL, ZEND_ACC_PUBLIC)
/* TODO: implement this stuff */
}
-static zend_function_entry dbh_methods[] = {
+static const zend_function_entry dbh_methods[] = {
PHP_FE(sqlite2_create_function, NULL)
{NULL, NULL, NULL}
};
-static zend_function_entry *get_driver_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
+static const zend_function_entry *get_driver_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
{
switch (kind) {
case PDO_DBH_DRIVER_METHOD_KIND_DBH:
enum { PHPSQLITE_ASSOC = 1, PHPSQLITE_NUM = 2, PHPSQLITE_BOTH = PHPSQLITE_ASSOC|PHPSQLITE_NUM };
-zend_function_entry sqlite_functions[] = {
+const zend_function_entry sqlite_functions[] = {
PHP_FE(sqlite_open, third_arg_force_ref)
PHP_FE(sqlite_popen, third_arg_force_ref)
PHP_FE(sqlite_close, NULL)
{NULL, NULL, NULL}
};
-zend_function_entry sqlite_funcs_db[] = {
+const zend_function_entry sqlite_funcs_db[] = {
PHP_ME_MAPPING(__construct, sqlite_open, third_arg_force_ref, 0)
/* PHP_ME_MAPPING(close, sqlite_close, NULL, 0)*/
PHP_ME_MAPPING(query, sqlite_query, third_arg_force_ref, 0)
{NULL, NULL, NULL}
};
-zend_function_entry sqlite_funcs_query[] = {
+const zend_function_entry sqlite_funcs_query[] = {
PHP_ME_MAPPING(fetch, sqlite_fetch_array, NULL, 0)
PHP_ME_MAPPING(fetchObject, sqlite_fetch_object, NULL, 0)
PHP_ME_MAPPING(fetchSingle, sqlite_fetch_single, NULL, 0)
{NULL, NULL, NULL}
};
-zend_function_entry sqlite_funcs_ub_query[] = {
+const zend_function_entry sqlite_funcs_ub_query[] = {
PHP_ME_MAPPING(fetch, sqlite_fetch_array, NULL, 0)
PHP_ME_MAPPING(fetchObject, sqlite_fetch_object, NULL, 0)
PHP_ME_MAPPING(fetchSingle, sqlite_fetch_single, NULL, 0)
{NULL, NULL, NULL}
};
-zend_function_entry sqlite_funcs_exception[] = {
+const zend_function_entry sqlite_funcs_exception[] = {
{NULL, NULL, NULL}
};
/* Dependancies */
-static zend_module_dep sqlite_deps[] = {
+static const zend_module_dep sqlite_deps[] = {
#if defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1))
ZEND_MOD_REQUIRED("spl")
#endif
/* }}} */
/* }}} */
-zend_function_entry basic_functions[] = {
+const zend_function_entry basic_functions[] = {
PHP_FE(constant, arginfo_constant)
PHP_FE(bin2hex, arginfo_bin2hex)
PHP_FE(sleep, arginfo_sleep)
PHP_INI_ENTRY_EX("safe_mode_allowed_env_vars", SAFE_MODE_ALLOWED_ENV_VARS, PHP_INI_SYSTEM, OnUpdateSafeModeAllowedEnvVars, NULL)
PHP_INI_END()
-static zend_module_dep standard_deps[] = {
+static const zend_module_dep standard_deps[] = {
ZEND_MOD_OPTIONAL("session")
{NULL, NULL, NULL}
};
RETURN_FALSE; \
}
-static zend_function_entry php_dir_class_functions[] = {
+static const zend_function_entry php_dir_class_functions[] = {
PHP_FALIAS(close, closedir, NULL)
PHP_FALIAS(rewind, rewinddir, NULL)
PHP_NAMED_FE(read, php_if_readdir, NULL)
unsigned int zend_api;
};
- char *name;
+ const char *name;
int zend_api;
unsigned char zend_debug, zts;
if (argc == 0) {
RETURN_STRING(PHP_VERSION, 1);
} else if (argc == 1 && zend_get_parameters_ex(1, &arg) == SUCCESS) {
- char *version;
+ const char *version;
convert_to_string_ex(arg);
version = zend_get_module_version(Z_STRVAL_PP(arg));
if (version == NULL) {
ZEND_BEGIN_ARG_INFO(arginfo_php_user_filter_onClose, 0)
ZEND_END_ARG_INFO()
-static zend_function_entry user_filter_class_funcs[] = {
+static const zend_function_entry user_filter_class_funcs[] = {
PHP_NAMED_FE(filter, PHP_FN(user_filter_nop), arginfo_php_user_filter_filter)
PHP_NAMED_FE(onCreate, PHP_FN(user_filter_nop), arginfo_php_user_filter_onCreate)
PHP_NAMED_FE(onClose, PHP_FN(user_filter_nop), arginfo_php_user_filter_onClose)
} sybase_result;
-zend_function_entry sybase_functions[] = {
+const zend_function_entry sybase_functions[] = {
PHP_FE(sybase_connect, NULL)
PHP_FE(sybase_pconnect, NULL)
PHP_FE(sybase_close, NULL)
static PHP_GINIT_FUNCTION(sybase);
static PHP_GSHUTDOWN_FUNCTION(sybase);
-zend_function_entry sybase_functions[] = {
+const zend_function_entry sybase_functions[] = {
PHP_FE(sybase_connect, NULL)
PHP_FE(sybase_pconnect, NULL)
PHP_FE(sybase_close, NULL)
*
* Every user visible function must have an entry in sysvmsg_functions[].
*/
-zend_function_entry sysvmsg_functions[] = {
+const zend_function_entry sysvmsg_functions[] = {
PHP_FE(msg_get_queue, NULL)
PHP_FE(msg_send, sixth_arg_force_ref)
PHP_FE(msg_receive, msg_receive_args_force_ref)
/* {{{ sysvsem_functions[]
*/
-zend_function_entry sysvsem_functions[] = {
+const zend_function_entry sysvsem_functions[] = {
PHP_FE(sem_get, NULL)
PHP_FE(sem_acquire, NULL)
PHP_FE(sem_release, NULL)
/* {{{ sysvshm_functions[]
*/
-zend_function_entry sysvshm_functions[] = {
+const zend_function_entry sysvshm_functions[] = {
PHP_FE(shm_attach, NULL)
PHP_FE(shm_remove, NULL)
PHP_FE(shm_detach, NULL)
PHP_INI_ENTRY("tidy.clean_output", "0", PHP_INI_PERDIR, NULL)
PHP_INI_END()
-static zend_function_entry tidy_functions[] = {
+static const zend_function_entry tidy_functions[] = {
PHP_FE(tidy_getopt, NULL)
PHP_FE(tidy_parse_string, NULL)
PHP_FE(tidy_parse_file, NULL)
{NULL, NULL, NULL}
};
-static zend_function_entry tidy_funcs_doc[] = {
+static const zend_function_entry tidy_funcs_doc[] = {
TIDY_METHOD_MAP(getOpt, tidy_getopt, NULL)
TIDY_METHOD_MAP(cleanRepair, tidy_clean_repair, NULL)
TIDY_DOC_ME(parseFile, NULL)
{NULL, NULL, NULL}
};
-static zend_function_entry tidy_funcs_node[] = {
+static const zend_function_entry tidy_funcs_node[] = {
TIDY_NODE_ME(hasChildren, NULL)
TIDY_NODE_ME(hasSiblings, NULL)
TIDY_NODE_ME(isComment, NULL)
*
* Every user visible function must have an entry in tokenizer_functions[].
*/
-zend_function_entry tokenizer_functions[] = {
+const zend_function_entry tokenizer_functions[] = {
PHP_FE(token_get_all, NULL)
PHP_FE(token_name, NULL)
{NULL, NULL, NULL} /* Must be the last line in tokenizer_functions[] */
/* {{{ wddx_functions[]
*/
-zend_function_entry wddx_functions[] = {
+const zend_function_entry wddx_functions[] = {
PHP_FE(wddx_serialize_value, NULL)
PHP_FE(wddx_serialize_vars, NULL)
PHP_FE(wddx_packet_start, NULL)
ZEND_ARG_PASS_INFO(1)
ZEND_END_ARG_INFO();
-zend_function_entry xml_functions[] = {
+const zend_function_entry xml_functions[] = {
PHP_FE(xml_parser_create, NULL)
PHP_FE(xml_parser_create_ns, NULL)
PHP_FE(xml_set_object, second_arg_force_ref)
};
#ifdef LIBXML_EXPAT_COMPAT
-static zend_module_dep xml_deps[] = {
+static const zend_module_dep xml_deps[] = {
ZEND_MOD_REQUIRED("libxml")
{NULL, NULL, NULL}
};
/* }}} */
#endif
-static zend_module_dep xmlreader_deps[] = {
+static const zend_module_dep xmlreader_deps[] = {
ZEND_MOD_REQUIRED("libxml")
{NULL, NULL, NULL}
};
ZEND_END_ARG_INFO()
/* }}} */
-static zend_function_entry xmlreader_functions[] = {
+static const zend_function_entry xmlreader_functions[] = {
PHP_ME(xmlreader, close, arginfo_xmlreader_close, ZEND_ACC_PUBLIC)
PHP_ME(xmlreader, getAttribute, arginfo_xmlreader_getAttribute, ZEND_ACC_PUBLIC)
PHP_ME(xmlreader, getAttributeNo, arginfo_xmlreader_getAttributeNo, ZEND_ACC_PUBLIC)
static int le_xmlrpc_server;
-zend_function_entry xmlrpc_functions[] = {
+const zend_function_entry xmlrpc_functions[] = {
PHP_FE(xmlrpc_encode, NULL)
PHP_FE(xmlrpc_decode, NULL)
PHP_FE(xmlrpc_decode_request, second_arg_force_ref)
} \
/* {{{ xmlwriter_functions */
-static zend_function_entry xmlwriter_functions[] = {
+static const zend_function_entry xmlwriter_functions[] = {
PHP_FE(xmlwriter_open_uri, NULL)
PHP_FE(xmlwriter_open_memory, NULL)
#if LIBXML_VERSION >= 20605
#ifdef ZEND_ENGINE_2
/* {{{ xmlwriter_class_functions */
-static zend_function_entry xmlwriter_class_functions[] = {
+static const zend_function_entry xmlwriter_class_functions[] = {
PHP_ME_MAPPING(openUri, xmlwriter_open_uri, NULL, 0)
PHP_ME_MAPPING(openMemory, xmlwriter_open_memory, NULL, 0)
#if LIBXML_VERSION >= 20605
*
* Every user visible function must have an entry in xsl_functions[].
*/
-zend_function_entry xsl_functions[] = {
+const zend_function_entry xsl_functions[] = {
{NULL, NULL, NULL} /* Must be the last line in xsl_functions[] */
};
/* }}} */
-static zend_module_dep xsl_deps[] = {
+static const zend_module_dep xsl_deps[] = {
ZEND_MOD_REQUIRED("libxml")
{NULL, NULL, NULL}
};
#ifndef XSL_FE_H
#define XSL_FE_H
-extern zend_function_entry php_xsl_xsltprocessor_class_functions[];
+extern const zend_function_entry php_xsl_xsltprocessor_class_functions[];
extern zend_class_entry *xsl_xsltprocessor_class_entry;
PHP_FUNCTION(xsl_xsltprocessor_import_stylesheet);
* Since:
*/
-zend_function_entry php_xsl_xsltprocessor_class_functions[] = {
+const zend_function_entry php_xsl_xsltprocessor_class_functions[] = {
PHP_FALIAS(importStylesheet, xsl_xsltprocessor_import_stylesheet, NULL)
PHP_FALIAS(transformToDoc, xsl_xsltprocessor_transform_to_doc, NULL)
PHP_FALIAS(transformToUri, xsl_xsltprocessor_transform_to_uri, NULL)
/* }}} */
/* {{{ zend_function_entry */
-static zend_function_entry zip_functions[] = {
+static const zend_function_entry zip_functions[] = {
PHP_FE(zip_open, NULL)
PHP_FE(zip_close, NULL)
PHP_FE(zip_read, NULL)
/* }}} */
/* {{{ ze_zip_object_class_functions */
-static zend_function_entry zip_class_functions[] = {
+static const zend_function_entry zip_class_functions[] = {
ZIPARCHIVE_ME(open, NULL, ZEND_ACC_PUBLIC)
ZIPARCHIVE_ME(close, NULL, ZEND_ACC_PUBLIC)
ZIPARCHIVE_ME(addEmptyDir, NULL, ZEND_ACC_PUBLIC)
/* {{{ php_zlib_functions[]
*/
-static zend_function_entry php_zlib_functions[] = {
+static const zend_function_entry php_zlib_functions[] = {
PHP_FE(readgzfile, NULL)
PHP_FALIAS(gzrewind, rewind, NULL)
PHP_FALIAS(gzclose, fclose, NULL)
PHP_FUNCTION(getallheaders);
-static zend_function_entry aolserver_functions[] = {
+const static zend_function_entry aolserver_functions[] = {
PHP_FE(getallheaders, NULL)
{NULL, NULL, NULL}
};
PHP_MINFO_FUNCTION(apache);
-zend_function_entry apache_functions[] = {
+const zend_function_entry apache_functions[] = {
PHP_FE(virtual, NULL)
PHP_FE(apache_request_headers, NULL)
PHP_FE(apache_note, NULL)
php_info_print_table_end();
}
-static zend_function_entry apache_functions[] = {
+static const zend_function_entry apache_functions[] = {
PHP_FE(apache_lookup_uri, NULL)
PHP_FE(virtual, NULL)
PHP_FE(apache_request_headers, NULL)
}
}
-static zend_function_entry apache_functions[] = {
+static const zend_function_entry apache_functions[] = {
PHP_FE(apache_lookup_uri, NULL)
PHP_FE(virtual, NULL)
PHP_FE(apache_request_headers, NULL)
PHP_MINFO_FUNCTION(apache);
-zend_function_entry apache_functions[] = {
+const zend_function_entry apache_functions[] = {
PHP_FE(virtual, NULL)
PHP_FE(apache_request_headers, NULL)
PHP_FE(apache_note, NULL)
/* {{{ php_apache_request_class_functions
*/
-static zend_function_entry php_apache_request_class_functions[] = {
+const static zend_function_entry php_apache_request_class_functions[] = {
/* string slots */
PHP_FALIAS(args, apache_request_args, NULL)
PHP_FALIAS(boundary, apache_request_boundary, NULL)
PHP_FUNCTION(continuity_request_headers);
PHP_FUNCTION(continuity_response_headers);
-zend_function_entry continuity_functions[] = {
+const zend_function_entry continuity_functions[] = {
{NULL, NULL, NULL}
};
/* {{{ milter_functions[]
*/
-static zend_function_entry milter_functions[] = {
+const static zend_function_entry milter_functions[] = {
PHP_FE(smfi_setflags, NULL)
PHP_FE(smfi_settimeout, NULL)
PHP_FE(smfi_getsymval, NULL)
*
* Every user visible function must have an entry in nsapi_functions[].
*/
-zend_function_entry nsapi_functions[] = {
+const zend_function_entry nsapi_functions[] = {
PHP_FE(nsapi_virtual, NULL) /* Make subrequest */
PHP_FALIAS(virtual, nsapi_virtual, NULL) /* compatibility */
PHP_FE(nsapi_request_headers, NULL) /* get request headers */
projects / php / commitdiff