diff --git a/Zend/zend.h b/Zend/zend.h
index 01daaa17be6..de96c1e3b17 100644
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -247,7 +247,7 @@ typedef union _zstr {
 #endif
 
 #ifdef __GNUC__
-#	define ZSTR(x)    ((zstr)(x))
+#	define ZSTR(x)    ((zstr)((void*)(x)))
 #	define NULL_ZSTR  ZSTR((void*)NULL)
 #	define EMPTY_ZSTR ZSTR("\0\0")
 #else
@@ -368,7 +368,7 @@ struct _zend_class_entry {
 	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;
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 7a5f3892d41..a9708185d11 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -1342,32 +1342,32 @@ ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-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_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_ascii_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value) /* {{{ */
+ZEND_API int add_ascii_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value) /* {{{ */
 {
 	return zend_ascii_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void*)&value, sizeof(zval*), NULL);
 }
 /* }}} */
 
-ZEND_API int add_rt_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value) /* {{{ */
+ZEND_API int add_rt_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value) /* {{{ */
 {
 	return zend_rt_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void*)&value, sizeof(zval*), NULL);
 }
 /* }}} */
 
-ZEND_API int add_utf8_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value) /* {{{ */
+ZEND_API int add_utf8_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value) /* {{{ */
 {
 	return zend_utf8_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void*)&value, sizeof(zval*), NULL);
 }
@@ -1391,7 +1391,7 @@ 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_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate) /* {{{ */
 {
 	zval *tmp;
 
@@ -1402,7 +1402,7 @@ ZEND_API int add_get_assoc_string_ex(zval *arg, char *key, uint key_len, char *s
 }
 /* }}} */
 
-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;
 
@@ -1435,7 +1435,7 @@ ZEND_API int add_get_index_double(zval *arg, ulong index, double d, void **dest)
 }
 /* }}} */
 
-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;
 
@@ -1446,7 +1446,7 @@ ZEND_API int add_get_index_string(zval *arg, ulong index, char *str, void **dest
 }
 /* }}} */
 
-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;
 
@@ -1833,7 +1833,7 @@ ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC) /* {{{
 
 	/* 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) {
@@ -1892,7 +1892,7 @@ static void zend_sort_modules(void *base, size_t count, size_t siz, compare_func
 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;
@@ -1939,7 +1939,7 @@ ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module TS
 
 	/* 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) {
@@ -2062,9 +2062,9 @@ ZEND_API void zend_check_magic_method_implementation(zend_class_entry *ce, zend_
 /* }}} */
 
 /* 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;
@@ -2100,7 +2100,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 			internal_function->function_name.u = malloc(UBYTES(len));
 			u_charsToUChars(ptr->fname, internal_function->function_name.u, len);
 		} else {
-			internal_function->function_name.s = ptr->fname;
+			internal_function->function_name.s = (char*)ptr->fname;
 		}
 		internal_function->scope = scope;
 		internal_function->prototype = NULL;
@@ -2125,7 +2125,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 					}
 				}
 			} else {
-				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 */
@@ -2333,9 +2333,9 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 /* 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;
 
@@ -2599,7 +2599,7 @@ static zend_object_value display_disabled_class(zend_class_entry *class_type TSR
 }
 /* }}} */
 
-static zend_function_entry disabled_class_new[] =  {
+static const zend_function_entry disabled_class_new[] =  {
 	{ NULL, NULL, NULL }
 };
 
@@ -3163,7 +3163,7 @@ ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *f
 }
 /* }}} */
 
-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);
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index 40fd16deaff..c6a591f988e 100644
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -33,9 +33,9 @@
 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;
@@ -68,7 +68,7 @@ typedef struct _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)
@@ -208,8 +208,8 @@ ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC,
 
 /* 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);
@@ -236,7 +236,7 @@ ZEND_API void zend_wrong_param_count(TSRMLS_D);
 ZEND_API zend_bool zend_is_callable_ex(zval *callable, uint check_flags, zval *callable_name, 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, zval *callable_name);
 ZEND_API zend_bool zend_make_callable(zval *callable, zval *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, zstr doc_comment, int doc_comment_len TSRMLS_DC);
@@ -336,12 +336,12 @@ ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTa
 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));
 
 #define ZSTR_DUPLICATE	(1<<0)
 #define ZSTR_AUTOFREE	(1<<1)
 
-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);
 
 #define add_assoc_null_ex(arg, key, key_len) do { \
 		zval *___tmp; \
@@ -485,7 +485,7 @@ ZEND_API int add_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value);
 #define add_assoc_text(arg, key, str, duplicate) add_assoc_text_ex(arg, key, strlen(key)+1, str, duplicate)
 #define add_assoc_textl(arg, key, str, length, duplicate) add_assoc_textl_ex(arg, key, strlen(key)+1, str, length, duplicate)
 
-ZEND_API int add_ascii_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value);
+ZEND_API int add_ascii_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
 
 #define add_ascii_assoc_null_ex(arg, key, key_len) do { \
 		zval *___tmp; \
@@ -630,7 +630,7 @@ ZEND_API int add_ascii_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *v
 #define add_ascii_assoc_text(__arg, __key, __str, __duplicate) add_ascii_assoc_text_ex(__arg, __key, strlen(__key)+1, __str, __duplicate)
 #define add_ascii_assoc_textl(__arg, __key, __str, __length, __duplicate) add_ascii_assoc_textl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate)
 
-ZEND_API int add_rt_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value);
+ZEND_API int add_rt_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
 
 #define add_rt_assoc_null_ex(arg, key, key_len) do { \
 		zval *___tmp; \
@@ -775,7 +775,7 @@ ZEND_API int add_rt_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *valu
 #define add_rt_assoc_text(__arg, __key, __str, __duplicate) add_rt_assoc_text_ex(__arg, __key, strlen(__key)+1, __str, __duplicate)
 #define add_rt_assoc_textl(__arg, __key, __str, __length, __duplicate) add_rt_assoc_textl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate)
 
-ZEND_API int add_utf8_assoc_zval_ex(zval *arg, char *key, uint key_len, zval *value);
+ZEND_API int add_utf8_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
 
 #define add_utf8_assoc_null_ex(arg, key, key_len) do { \
 		zval *___tmp; \
@@ -1401,7 +1401,7 @@ ZEND_API int add_next_index_zval(zval *arg, zval *value);
 			UChar *___u_str = zend_ascii_to_unicode((str), (___u_len)+1 ZEND_FILE_LINE_CC); \
 			___u_str[___u_len] = 0; \
 			if ((flags) & ZSTR_AUTOFREE) { \
-				efree(str); \
+				efree((char*)(str)); \
 			} \
 			add_next_index_unicodel(arg, ___u_str, ___u_len, 0); \
 		} else { \
@@ -1416,7 +1416,7 @@ ZEND_API int add_next_index_zval(zval *arg, zval *value);
 				add_next_index_unicodel(arg, ___u_str, ___u_len, 0); \
 			} \
 			if ((flags) & ZSTR_AUTOFREE) { \
-				efree(str); \
+				efree((char*)(str)); \
 			} \
 		} else { \
 			add_next_index_stringl(arg, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \
@@ -1430,7 +1430,7 @@ ZEND_API int add_next_index_zval(zval *arg, zval *value);
 				add_next_index_unicodel(arg, ___u_str, ___u_len, 0); \
 			} \
 			if ((flags) & ZSTR_AUTOFREE) { \
-				efree(str); \
+				efree((char*)(str)); \
 			} \
 		} else { \
 			add_next_index_stringl(arg, (char*)(str), length, (flags) & ZSTR_DUPLICATE); \
@@ -1448,16 +1448,16 @@ ZEND_API int add_next_index_zval(zval *arg, zval *value);
 #define add_next_index_unset(__arg) add_next_index_null(__arg)
 #define add_property_unset(__arg, __key) add_property_null(__arg, __key)
 
-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_get_index_unicode(zval *arg, ulong idx, UChar *str, void **dest, int duplicate);
 ZEND_API int add_get_index_unicodel(zval *arg, ulong idx, UChar *str, uint length, void **dest, int duplicate);
 
@@ -1636,22 +1636,22 @@ END_EXTERN_C()
 	}
 
 #define ZVAL_STRING(z, s, duplicate) {	\
-		char *__s=(s);					\
+		const char *__s=(s);					\
 		Z_STRLEN_P(z) = strlen(__s);	\
-		Z_STRVAL_P(z) = (duplicate?estrndup(__s, Z_STRLEN_P(z)):__s);	\
+		Z_STRVAL_P(z) = (duplicate?estrndup(__s, Z_STRLEN_P(z)):(char*)__s);	\
 		Z_TYPE_P(z) = IS_STRING;        \
 	}
 
 #define ZVAL_STRINGL(z, s, l, duplicate) {	\
-		char *__s=(s); int __l=l;		\
+		const char *__s=(s); int __l=l;		\
 		Z_STRLEN_P(z) = __l;		    \
-		Z_STRVAL_P(z) = (duplicate?estrndup(__s, __l):__s);	\
+		Z_STRVAL_P(z) = (duplicate?estrndup(__s, __l):(char*)__s);	\
 		Z_TYPE_P(z) = IS_STRING;		    \
 	}
 
 #define ZVAL_ASCII_STRING(z, s, flags) { \
 		if (UG(unicode)) { \
-			char *__s = (s); \
+			char *__s = (char*)(s); \
 			int __s_len = strlen(__s); \
 			UChar *u_str = zend_ascii_to_unicode(__s, __s_len+1 ZEND_FILE_LINE_CC); \
 			u_str[__s_len] = 0; \
@@ -1660,16 +1660,16 @@ END_EXTERN_C()
 			} \
 			ZVAL_UNICODEL(z, u_str, __s_len, 0); \
 		} else { \
-			char *__s=(s);					\
+			const char *__s=(s);					\
 			Z_STRLEN_P(z) = strlen(__s);	\
-			Z_STRVAL_P(z) = (((flags) & ZSTR_DUPLICATE) ? estrndup(__s, Z_STRLEN_P(z)) : __s);	\
+			Z_STRVAL_P(z) = (((flags) & ZSTR_DUPLICATE) ? estrndup(__s, Z_STRLEN_P(z)) :(char*) __s);	\
 			Z_TYPE_P(z) = IS_STRING;        \
 		} \
 	}
 
 #define ZVAL_ASCII_STRINGL(z, s, l, flags) { \
 		if (UG(unicode)) { \
-			char *__s = (s); \
+			char *__s = (char*)(s); \
 			int __s_len  = (l); \
 			UChar *u_str = zend_ascii_to_unicode((__s), (__s_len)+1 ZEND_FILE_LINE_CC); \
 			u_str[__s_len] = 0; \
@@ -1678,9 +1678,9 @@ END_EXTERN_C()
 			} \
 			ZVAL_UNICODEL(z, u_str, __s_len, 0); \
 		} else { \
-			char *__s=(s); int __l=l;	\
+			const char *__s=(s); int __l=l;	\
 			Z_STRLEN_P(z) = __l;	    \
-			Z_STRVAL_P(z) = (((flags) & ZSTR_DUPLICATE) ? estrndup(__s, __l) : __s);	\
+			Z_STRVAL_P(z) = (((flags) & ZSTR_DUPLICATE) ? estrndup(__s, __l) : (char*)__s);	\
 			Z_TYPE_P(z) = IS_STRING;    \
 		} \
 	}
@@ -1700,7 +1700,7 @@ END_EXTERN_C()
 		} else { \
 			char *__s=(char *)(s);					\
 			Z_STRLEN_P(z) = strlen(__s);	\
-			Z_STRVAL_P(z) = (((flags) & ZSTR_DUPLICATE) ? estrndup(__s, Z_STRLEN_P(z)) : __s);	\
+			Z_STRVAL_P(z) = (((flags) & ZSTR_DUPLICATE) ? estrndup(__s, Z_STRLEN_P(z)) : (char*)__s);	\
 			Z_TYPE_P(z) = IS_STRING;        \
 		} \
 	}
diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index 059867e60cf..0be6086a436 100644
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -89,7 +89,7 @@ static ZEND_FUNCTION(zend_thread_id);
 
 #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)
@@ -1728,7 +1728,7 @@ ZEND_FUNCTION(get_defined_constants)
 		zend_constant *val;
 		int module_number;
 		zval **modules;
-		char **module_names;
+		const char **module_names;
 		zend_module_entry *module;
 		int i = 1;
 
@@ -2282,7 +2282,7 @@ ZEND_FUNCTION(get_extension_funcs)
 	zend_uchar ext_type;
 	char *name;
 	zend_module_entry *module;
-	zend_function_entry *func;
+	const zend_function_entry *func;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "t", &ext, &ext_len, &ext_type) == FAILURE) {
 		return;
diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c
index 0b2070d1173..64604520c67 100644
--- a/Zend/zend_exceptions.c
+++ b/Zend/zend_exceptions.c
@@ -620,7 +620,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_exception___construct, 0, 0, 0)
 	ZEND_ARG_INFO(0, code)
 ZEND_END_ARG_INFO()
 
-static zend_function_entry default_exception_functions[] = {
+static const 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)
@@ -642,7 +642,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_error_exception___construct, 0, 0, 0)
 	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}
diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c
index 20391dc3e8b..5e2efac4945 100644
--- a/Zend/zend_hash.c
+++ b/Zend/zend_hash.c
@@ -126,7 +126,7 @@ ZEND_API ulong zend_u_hash_func(zend_uchar type, zstr arKey, uint nKeyLength) /*
 }
 /* }}} */
 
-ZEND_API ulong zend_hash_func(char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength) /* {{{ */
 {
 	return zend_u_hash_func(IS_STRING, ZSTR(arKey), nKeyLength);
 }
@@ -323,13 +323,13 @@ ZEND_API int _zend_u_hash_add_or_update(HashTable *ht, zend_uchar type, zstr arK
 }
 /* }}} */
 
-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) /* {{{ */
 {
 	return _zend_u_hash_add_or_update(ht, IS_STRING, ZSTR(arKey), nKeyLength, pData, nDataSize, pDest, flag ZEND_FILE_LINE_CC);
 }
 /* }}} */
 
-ZEND_API int _zend_ascii_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_ascii_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -347,7 +347,7 @@ ZEND_API int _zend_ascii_hash_add_or_update(HashTable *ht, char *arKey, uint nKe
 }
 /* }}} */
 
-ZEND_API int _zend_rt_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_rt_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -373,7 +373,7 @@ string_key:
 }
 /* }}} */
 
-ZEND_API int _zend_utf8_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_utf8_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -483,7 +483,7 @@ ZEND_API int _zend_u_hash_quick_add_or_update(HashTable *ht, zend_uchar type, zs
 }
 /* }}} */
 
-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) /* {{{ */
 {
 	return _zend_u_hash_quick_add_or_update(ht, IS_STRING, ZSTR(arKey), nKeyLength, h, pData, nDataSize, pDest, flag ZEND_FILE_LINE_CC);
 }
@@ -497,7 +497,7 @@ ZEND_API int zend_u_hash_add_empty_element(HashTable *ht, zend_uchar type, zstr
 }
 /* }}} */
 
-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;
 
@@ -682,13 +682,13 @@ ZEND_API int zend_u_hash_del_key_or_index(HashTable *ht, zend_uchar type, zstr a
 }
 /* }}} */
 
-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) /* {{{ */
 {
 	return zend_u_hash_del_key_or_index(ht, IS_STRING, ZSTR(arKey), nKeyLength, h, flag);
 }
 /* }}} */
 
-ZEND_API int zend_ascii_hash_del(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_ascii_hash_del(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -706,7 +706,7 @@ ZEND_API int zend_ascii_hash_del(HashTable *ht, char *arKey, uint nKeyLength) /*
 }
 /* }}} */
 
-ZEND_API int zend_rt_hash_del(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_rt_hash_del(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -731,7 +731,7 @@ string_key:
 }
 /* }}} */
 
-ZEND_API int zend_utf8_hash_del(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_utf8_hash_del(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -1117,7 +1117,7 @@ ZEND_API ulong zend_u_get_hash_value(zend_uchar type, zstr arKey, uint nKeyLengt
 }
 /* }}} */
 
-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_u_get_hash_value(IS_STRING, ZSTR(arKey), nKeyLength);
 }
@@ -1160,13 +1160,13 @@ ZEND_API int zend_u_hash_find(HashTable *ht, zend_uchar type, zstr arKey, uint n
 }
 /* }}} */
 
-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) /* {{{ */
 {
 	return zend_u_hash_find(ht, IS_STRING, ZSTR(arKey), nKeyLength, pData);
 }
 /* }}} */
 
-ZEND_API int zend_ascii_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) /* {{{ */
+ZEND_API int zend_ascii_hash_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -1184,7 +1184,7 @@ ZEND_API int zend_ascii_hash_find(HashTable *ht, char *arKey, uint nKeyLength, v
 }
 /* }}} */
 
-ZEND_API int zend_rt_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) /* {{{ */
+ZEND_API int zend_rt_hash_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -1209,7 +1209,7 @@ string_key:
 }
 /* }}} */
 
-ZEND_API int zend_utf8_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) /* {{{ */
+ZEND_API int zend_utf8_hash_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -1272,7 +1272,7 @@ ZEND_API int zend_u_hash_quick_find(HashTable *ht, zend_uchar type, zstr arKey,
 }
 /* }}} */
 
-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) /* {{{ */
 {
 	return zend_u_hash_quick_find(ht, IS_STRING, ZSTR(arKey), nKeyLength, h, pData);
 }
@@ -1310,13 +1310,13 @@ ZEND_API int zend_u_hash_exists(HashTable *ht, zend_uchar type, zstr arKey, uint
 }
 /* }}} */
 
-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) /* {{{ */
 {
 	return zend_u_hash_exists(ht, IS_STRING, ZSTR(arKey), nKeyLength);
 }
 /* }}} */
 
-ZEND_API int zend_ascii_hash_exists(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_ascii_hash_exists(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -1334,7 +1334,7 @@ ZEND_API int zend_ascii_hash_exists(HashTable *ht, char *arKey, uint nKeyLength)
 }
 /* }}} */
 
-ZEND_API int zend_rt_hash_exists(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_rt_hash_exists(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -1359,7 +1359,7 @@ string_key:
 }
 /* }}} */
 
-ZEND_API int zend_utf8_hash_exists(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_utf8_hash_exists(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	TSRMLS_FETCH();
 
@@ -1421,7 +1421,7 @@ ZEND_API int zend_u_hash_quick_exists(HashTable *ht, zend_uchar type, zstr arKey
 }
 /* }}} */
 
-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) /* {{{ */
 {
 	return zend_u_hash_quick_exists(ht, IS_STRING, ZSTR(arKey), nKeyLength, h);
 }
@@ -1937,13 +1937,13 @@ ZEND_API ulong zend_hash_next_free_element(HashTable *ht) /* {{{ */
 
 /* {{{ HANDLE_*_NUMERIC macros */
 #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 */	\
@@ -2066,119 +2066,119 @@ ZEND_API int zend_u_symtable_update_current_key(HashTable *ht, zend_uchar type,
 }
 /* }}} */
 
-ZEND_API int zend_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest) /* {{{ */
+ZEND_API 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);
 }
 /* }}} */
 
-ZEND_API int zend_symtable_del(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API 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);
 }
 /* }}} */
 
-ZEND_API int zend_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) /* {{{ */
+ZEND_API 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);
 }
 /* }}} */
 
-ZEND_API int zend_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API 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);
 }
 /* }}} */
 
-ZEND_API int zend_symtable_update_current_key(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API 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_ZSTR, 0, idx));
 	return zend_hash_update_current_key(ht, HASH_KEY_IS_STRING, ZSTR(arKey), nKeyLength, 0);
 }
 /* }}} */
 
-ZEND_API int zend_ascii_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest) /* {{{ */
+ZEND_API int zend_ascii_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_ascii_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest);
 }
 /* }}} */
 
-ZEND_API int zend_ascii_symtable_del(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_ascii_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_del(ht, idx))
 	return zend_ascii_hash_del(ht, arKey, nKeyLength);
 }
 /* }}} */
 
-ZEND_API int zend_ascii_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) /* {{{ */
+ZEND_API int zend_ascii_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData) /* {{{ */
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData));
 	return zend_ascii_hash_find(ht, arKey, nKeyLength, pData);
 }
 /* }}} */
 
-ZEND_API int zend_ascii_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_ascii_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx));
 	return zend_ascii_hash_exists(ht, arKey, nKeyLength);
 }
 /* }}} */
 
-ZEND_API int zend_rt_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest) /* {{{ */
+ZEND_API int zend_rt_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_rt_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest);
 }
 /* }}} */
 
-ZEND_API int zend_rt_symtable_del(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_rt_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_del(ht, idx))
 	return zend_rt_hash_del(ht, arKey, nKeyLength);
 }
 /* }}} */
 
-ZEND_API int zend_rt_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) /* {{{ */
+ZEND_API int zend_rt_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData) /* {{{ */
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData));
 	return zend_rt_hash_find(ht, arKey, nKeyLength, pData);
 }
 /* }}} */
 
-ZEND_API int zend_rt_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_rt_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx));
 	return zend_rt_hash_exists(ht, arKey, nKeyLength);
 }
 /* }}} */
 
-ZEND_API int zend_utf8_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest) /* {{{ */
+ZEND_API int zend_utf8_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_utf8_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest);
 }
 /* }}} */
 
-ZEND_API int zend_utf8_symtable_del(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_utf8_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_del(ht, idx))
 	return zend_utf8_hash_del(ht, arKey, nKeyLength);
 }
 /* }}} */
 
-ZEND_API int zend_utf8_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData) /* {{{ */
+ZEND_API int zend_utf8_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData) /* {{{ */
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData));
 	return zend_utf8_hash_find(ht, arKey, nKeyLength, pData);
 }
 /* }}} */
 
-ZEND_API int zend_utf8_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength) /* {{{ */
+ZEND_API int zend_utf8_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength) /* {{{ */
 {
 	HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx));
 	return zend_utf8_hash_exists(ht, arKey, nKeyLength);
diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h
index 2de1fef6e40..3c40661a9b8 100644
--- a/Zend/zend_hash.h
+++ b/Zend/zend_hash.h
@@ -39,7 +39,7 @@
 
 
 
-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);
@@ -115,10 +115,10 @@ ZEND_API void zend_hash_clean(HashTable *ht);
 #define zend_u_hash_init_ex(ht, nSize, pHashFunction, pDestructor, persistent, unicode, bApplyProtection)		_zend_u_hash_init_ex((ht), (nSize), (pHashFunction), (pDestructor), (persistent), (unicode), (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_ascii_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_rt_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_utf8_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);
+ZEND_API int _zend_ascii_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
+ZEND_API int _zend_rt_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
+ZEND_API int _zend_utf8_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
 ZEND_API int _zend_u_hash_add_or_update(HashTable *ht, zend_uchar type, zstr 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)
@@ -141,7 +141,7 @@ ZEND_API int _zend_u_hash_add_or_update(HashTable *ht, zend_uchar type, zstr arK
 #define zend_u_hash_add(ht, type, arKey, nKeyLength, pData, nDataSize, pDest) \
 		_zend_u_hash_add_or_update(ht, type, 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);
 ZEND_API int _zend_u_hash_quick_add_or_update(HashTable *ht, zend_uchar type, zstr 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)
@@ -158,7 +158,7 @@ ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void
 #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);
 ZEND_API int zend_u_hash_add_empty_element(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength);
 
 
@@ -188,10 +188,10 @@ ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSR
 ZEND_API void zend_hash_to_unicode(HashTable *ht, apply_func_t apply_func TSRMLS_DC);
 
 /* Deletes */
-ZEND_API int zend_hash_del_key_or_index(HashTable *ht, char *arKey, uint nKeyLength, ulong h, int flag);
-ZEND_API int zend_ascii_hash_del(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_rt_hash_del(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_utf8_hash_del(HashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, int flag);
+ZEND_API int zend_ascii_hash_del(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_rt_hash_del(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_utf8_hash_del(HashTable *ht, const char *arKey, uint nKeyLength);
 ZEND_API int zend_u_hash_del_key_or_index(HashTable *ht, zend_uchar type, zstr 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)
@@ -200,26 +200,26 @@ ZEND_API int zend_u_hash_del_key_or_index(HashTable *ht, zend_uchar type, zstr a
 #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);
 ZEND_API ulong zend_u_get_hash_value(zend_uchar type, zstr arKey, uint nKeyLength);
 
 /* Data retreival */
-ZEND_API int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_ascii_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_rt_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_utf8_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);
+ZEND_API int zend_ascii_hash_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
+ZEND_API int zend_rt_hash_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
+ZEND_API int zend_utf8_hash_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
 ZEND_API int zend_u_hash_find(HashTable *ht, zend_uchar type, zstr 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_quick_find(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void **pData);
 ZEND_API int zend_u_hash_quick_find(HashTable *ht, zend_uchar type, zstr 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_ascii_hash_exists(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_rt_hash_exists(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_utf8_hash_exists(HashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_hash_exists(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_ascii_hash_exists(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_rt_hash_exists(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_utf8_hash_exists(HashTable *ht, const char *arKey, uint nKeyLength);
 ZEND_API int zend_u_hash_exists(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength);
-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);
 ZEND_API int zend_u_hash_quick_exists(HashTable *ht, zend_uchar type, zstr 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);
@@ -312,7 +312,7 @@ ZEND_API int zend_hash_rehash(HashTable *ht);
  *                  -- 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;
 
@@ -344,7 +344,7 @@ EMPTY_SWITCH_DEFAULT_CASE()
 #define zend_u_inline_hash_func(type, arKey, nKeyLength) \
 	zend_inline_hash_func(arKey.s, USTR_BYTES(type, nKeyLength))
 
-ZEND_API ulong zend_hash_func(char *arKey, uint nKeyLength);
+ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength);
 ZEND_API ulong zend_u_hash_func(zend_uchar type, zstr arKey, uint nKeyLength);
 
 #if ZEND_DEBUG
@@ -362,26 +362,26 @@ END_EXTERN_C()
 	zend_hash_init(ht, n, NULL, ZVAL_PTR_DTOR, persistent)
 
 
-ZEND_API int zend_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest);
-ZEND_API int zend_symtable_del(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_symtable_update_current_key(HashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_symtable_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest);
+ZEND_API int zend_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
+ZEND_API int zend_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_symtable_update_current_key(HashTable *ht, const char *arKey, uint nKeyLength);
 
-ZEND_API int zend_ascii_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest);
-ZEND_API int zend_ascii_symtable_del(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_ascii_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_ascii_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_ascii_symtable_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest);
+ZEND_API int zend_ascii_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_ascii_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
+ZEND_API int zend_ascii_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength);
 
-ZEND_API int zend_rt_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest);
-ZEND_API int zend_rt_symtable_del(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_rt_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_rt_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_rt_symtable_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest);
+ZEND_API int zend_rt_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_rt_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
+ZEND_API int zend_rt_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength);
 
-ZEND_API int zend_utf8_symtable_update(HashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest);
-ZEND_API int zend_utf8_symtable_del(HashTable *ht, char *arKey, uint nKeyLength);
-ZEND_API int zend_utf8_symtable_find(HashTable *ht, char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_utf8_symtable_exists(HashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_utf8_symtable_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest);
+ZEND_API int zend_utf8_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API int zend_utf8_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
+ZEND_API int zend_utf8_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength);
 
 ZEND_API int zend_u_symtable_update(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest);
 ZEND_API int zend_u_symtable_del(HashTable *ht, zend_uchar type, zstr arKey, uint nKeyLength);
diff --git a/Zend/zend_ini.c b/Zend/zend_ini.c
index 9844295ffbf..7028febf23c 100644
--- a/Zend/zend_ini.c
+++ b/Zend/zend_ini.c
@@ -165,9 +165,9 @@ ZEND_API void zend_ini_sort_entries(TSRMLS_D) /* {{{ */
 /*
  * 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;
@@ -188,12 +188,12 @@ ZEND_API int zend_register_ini_entries(zend_ini_entry *ini_entry, int module_num
 #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) {
diff --git a/Zend/zend_ini.h b/Zend/zend_ini.h
index ce40932dbef..5fa0fdf059d 100644
--- a/Zend/zend_ini.h
+++ b/Zend/zend_ini.h
@@ -92,7 +92,7 @@ ZEND_API int zend_copy_ini_directives(TSRMLS_D);
 
 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);
@@ -111,7 +111,7 @@ ZEND_API ZEND_INI_DISP(zend_ini_color_displayer_cb);
 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) \
diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c
index 19c9337a78c..b8460042e17 100755
--- a/Zend/zend_interfaces.c
+++ b/Zend/zend_interfaces.c
@@ -485,12 +485,12 @@ static int zend_implement_serializable(zend_class_entry *interface, zend_class_e
 /* }}}*/
 
 /* {{{ 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)
@@ -499,7 +499,7 @@ zend_function_entry zend_funcs_iterator[] = {
 	{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)
@@ -517,7 +517,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_arrayaccess_offset_value, 0, 0, 2)
 	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)
@@ -530,7 +530,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_serializable_serialize, 0)
 	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}
diff --git a/Zend/zend_modules.h b/Zend/zend_modules.h
index 971f202bb39..f3495f2ef7c 100644
--- a/Zend/zend_modules.h
+++ b/Zend/zend_modules.h
@@ -32,12 +32,12 @@
 #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
@@ -79,10 +79,10 @@ struct _zend_module_entry {
 	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);
diff --git a/ext/bcmath/bcmath.c b/ext/bcmath/bcmath.c
index 44e1536159a..be7a4741abb 100644
--- a/ext/bcmath/bcmath.c
+++ b/ext/bcmath/bcmath.c
@@ -105,7 +105,7 @@ ZEND_END_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)
diff --git a/ext/bz2/bz2.c b/ext/bz2/bz2.c
index 0d27995525b..0d83e41d31f 100644
--- a/ext/bz2/bz2.c
+++ b/ext/bz2/bz2.c
@@ -94,7 +94,7 @@ ZEND_END_ARG_INFO()
 
 /* }}} */
 
-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)
diff --git a/ext/calendar/calendar.c b/ext/calendar/calendar.c
index 5ecbade3534..eec315479bd 100644
--- a/ext/calendar/calendar.c
+++ b/ext/calendar/calendar.c
@@ -147,7 +147,7 @@ ZEND_END_ARG_INFO()
 
 /* }}} */
 
-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)
diff --git a/ext/com_dotnet/com_extension.c b/ext/com_dotnet/com_extension.c
index 5150013105e..4d88a4fd546 100644
--- a/ext/com_dotnet/com_extension.c
+++ b/ext/com_dotnet/com_extension.c
@@ -39,7 +39,7 @@ zend_class_entry
    	*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)
diff --git a/ext/com_dotnet/com_persist.c b/ext/com_dotnet/com_persist.c
index 7a803805f85..3513fa0ecde 100755
--- a/ext/com_dotnet/com_persist.c
+++ b/ext/com_dotnet/com_persist.c
@@ -678,7 +678,7 @@ CPH_METHOD(__construct)
 
 
 
-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)
diff --git a/ext/ctype/ctype.c b/ext/ctype/ctype.c
index 050150fe17e..abf8466653c 100644
--- a/ext/ctype/ctype.c
+++ b/ext/ctype/ctype.c
@@ -105,7 +105,7 @@ ZEND_END_ARG_INFO()
 /* {{{ 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)
diff --git a/ext/curl/interface.c b/ext/curl/interface.c
index f500fd68f81..d47dad8ece3 100644
--- a/ext/curl/interface.c
+++ b/ext/curl/interface.c
@@ -289,7 +289,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ 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)
diff --git a/ext/date/php_date.c b/ext/date/php_date.c
index 930cec6f1fc..69187dd9567 100644
--- a/ext/date/php_date.c
+++ b/ext/date/php_date.c
@@ -149,7 +149,7 @@ ZEND_END_ARG_INFO()
 /* }}} */
 
 /* {{{ 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)
@@ -201,7 +201,7 @@ zend_function_entry date_functions[] = {
 };
 
 
-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)
@@ -214,7 +214,7 @@ zend_function_entry date_funcs_date[] = {
 	{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)
@@ -305,7 +305,7 @@ static int date_object_compare_date(zval *d1, zval *d2 TSRMLS_DC);
 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}
 };
diff --git a/ext/dba/dba.c b/ext/dba/dba.c
index 8156d6608bc..a24d133e970 100644
--- a/ext/dba/dba.c
+++ b/ext/dba/dba.c
@@ -144,7 +144,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ 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)
diff --git a/ext/dbase/dbase.c b/ext/dbase/dbase.c
index 27cde272354..aa302eb8105 100644
--- a/ext/dbase/dbase.c
+++ b/ext/dbase/dbase.c
@@ -803,7 +803,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ 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)
diff --git a/ext/dom/attr.c b/ext/dom/attr.c
index e82c0d93341..e50f009d245 100644
--- a/ext/dom/attr.c
+++ b/ext/dom/attr.c
@@ -37,7 +37,7 @@
 * 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}
diff --git a/ext/dom/cdatasection.c b/ext/dom/cdatasection.c
index 9931cbff297..eb451e994bf 100644
--- a/ext/dom/cdatasection.c
+++ b/ext/dom/cdatasection.c
@@ -35,7 +35,7 @@
 * 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}
 };
diff --git a/ext/dom/characterdata.c b/ext/dom/characterdata.c
index 448e4eb0b66..d40f40aa243 100644
--- a/ext/dom/characterdata.c
+++ b/ext/dom/characterdata.c
@@ -35,7 +35,7 @@
 * 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)
diff --git a/ext/dom/comment.c b/ext/dom/comment.c
index 4d68ae5a393..a0670428c70 100644
--- a/ext/dom/comment.c
+++ b/ext/dom/comment.c
@@ -35,7 +35,7 @@
 * 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}
 };
diff --git a/ext/dom/document.c b/ext/dom/document.c
index 30b31a3240b..54bb94720da 100644
--- a/ext/dom/document.c
+++ b/ext/dom/document.c
@@ -50,7 +50,7 @@ struct _idsIterator {
 * 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)
diff --git a/ext/dom/documentfragment.c b/ext/dom/documentfragment.c
index caca6f92390..10805133d28 100644
--- a/ext/dom/documentfragment.c
+++ b/ext/dom/documentfragment.c
@@ -35,7 +35,7 @@
 * 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}
diff --git a/ext/dom/documenttype.c b/ext/dom/documenttype.c
index ffeda243a44..196d4ed343d 100644
--- a/ext/dom/documenttype.c
+++ b/ext/dom/documenttype.c
@@ -34,7 +34,7 @@
 * Since: 
 */
 
-zend_function_entry php_dom_documenttype_class_functions[] = {
+const zend_function_entry php_dom_documenttype_class_functions[] = {
 	{NULL, NULL, NULL}
 };
 
diff --git a/ext/dom/dom_fe.h b/ext/dom/dom_fe.h
index 06dc8c917e7..46f298684b1 100644
--- a/ext/dom/dom_fe.h
+++ b/ext/dom/dom_fe.h
@@ -21,36 +21,36 @@
 #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 {
diff --git a/ext/dom/domconfiguration.c b/ext/dom/domconfiguration.c
index 727cd086293..85d12fb0012 100644
--- a/ext/dom/domconfiguration.c
+++ b/ext/dom/domconfiguration.c
@@ -35,7 +35,7 @@
 * 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)
diff --git a/ext/dom/domerror.c b/ext/dom/domerror.c
index 8bce0cda4ad..68e3c07c17b 100644
--- a/ext/dom/domerror.c
+++ b/ext/dom/domerror.c
@@ -35,7 +35,7 @@
 * Since: DOM Level 3
 */
 
-zend_function_entry php_dom_domerror_class_functions[] = {
+const zend_function_entry php_dom_domerror_class_functions[] = {
 	{NULL, NULL, NULL}
 };
 
diff --git a/ext/dom/domerrorhandler.c b/ext/dom/domerrorhandler.c
index be2594217ac..bb7b6a30824 100644
--- a/ext/dom/domerrorhandler.c
+++ b/ext/dom/domerrorhandler.c
@@ -35,7 +35,7 @@
 * 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}
 };
diff --git a/ext/dom/domexception.c b/ext/dom/domexception.c
index 42aa341ada9..9a65f51259b 100644
--- a/ext/dom/domexception.c
+++ b/ext/dom/domexception.c
@@ -37,7 +37,7 @@
 
 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}
 };
 
diff --git a/ext/dom/domimplementation.c b/ext/dom/domimplementation.c
index 7f9ec43048e..d398f79b46d 100644
--- a/ext/dom/domimplementation.c
+++ b/ext/dom/domimplementation.c
@@ -34,7 +34,7 @@
 * 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)
diff --git a/ext/dom/domimplementationlist.c b/ext/dom/domimplementationlist.c
index afc2fd288b2..206913e3103 100644
--- a/ext/dom/domimplementationlist.c
+++ b/ext/dom/domimplementationlist.c
@@ -35,7 +35,7 @@
 * 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}
 };
diff --git a/ext/dom/domimplementationsource.c b/ext/dom/domimplementationsource.c
index a9fb1913532..475768be398 100644
--- a/ext/dom/domimplementationsource.c
+++ b/ext/dom/domimplementationsource.c
@@ -35,7 +35,7 @@
 * 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}
diff --git a/ext/dom/domlocator.c b/ext/dom/domlocator.c
index c98067106cb..ae3b795b8d3 100644
--- a/ext/dom/domlocator.c
+++ b/ext/dom/domlocator.c
@@ -35,7 +35,7 @@
 * Since: DOM Level 3
 */
 
-zend_function_entry php_dom_domlocator_class_functions[] = {
+const zend_function_entry php_dom_domlocator_class_functions[] = {
 	{NULL, NULL, NULL}
 };
 
diff --git a/ext/dom/domstringlist.c b/ext/dom/domstringlist.c
index 6ade1dd2e30..84bd5d75385 100644
--- a/ext/dom/domstringlist.c
+++ b/ext/dom/domstringlist.c
@@ -35,7 +35,7 @@
 * 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}
 };
diff --git a/ext/dom/element.c b/ext/dom/element.c
index 21d65c53f9d..9cec9577e5a 100644
--- a/ext/dom/element.c
+++ b/ext/dom/element.c
@@ -35,7 +35,7 @@
 * 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)
diff --git a/ext/dom/entity.c b/ext/dom/entity.c
index adc6b54d82f..3bc939b640a 100644
--- a/ext/dom/entity.c
+++ b/ext/dom/entity.c
@@ -35,7 +35,7 @@
 * Since: 
 */
 
-zend_function_entry php_dom_entity_class_functions[] = {
+const zend_function_entry php_dom_entity_class_functions[] = {
 	{NULL, NULL, NULL}
 };
 
diff --git a/ext/dom/entityreference.c b/ext/dom/entityreference.c
index ba1de0a97fb..d2e5d701e24 100644
--- a/ext/dom/entityreference.c
+++ b/ext/dom/entityreference.c
@@ -35,7 +35,7 @@
 * 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}
 };
diff --git a/ext/dom/namednodemap.c b/ext/dom/namednodemap.c
index f2b0cad4380..c1269fe252e 100644
--- a/ext/dom/namednodemap.c
+++ b/ext/dom/namednodemap.c
@@ -35,7 +35,7 @@
 * 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)
diff --git a/ext/dom/namelist.c b/ext/dom/namelist.c
index 4e49f08ddfb..31882e78b88 100644
--- a/ext/dom/namelist.c
+++ b/ext/dom/namelist.c
@@ -35,7 +35,7 @@
 * 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}
diff --git a/ext/dom/node.c b/ext/dom/node.c
index 226badaa721..81e4e5c10cd 100644
--- a/ext/dom/node.c
+++ b/ext/dom/node.c
@@ -34,7 +34,7 @@
 * 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)
diff --git a/ext/dom/nodelist.c b/ext/dom/nodelist.c
index 4c36e2c6ca5..20bb36d2be5 100644
--- a/ext/dom/nodelist.c
+++ b/ext/dom/nodelist.c
@@ -35,7 +35,7 @@
 * 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}
 };
diff --git a/ext/dom/notation.c b/ext/dom/notation.c
index c045e4254a3..3517933474f 100644
--- a/ext/dom/notation.c
+++ b/ext/dom/notation.c
@@ -35,7 +35,7 @@
 * Since: 
 */
 
-zend_function_entry php_dom_notation_class_functions[] = {
+const zend_function_entry php_dom_notation_class_functions[] = {
 	{NULL, NULL, NULL}
 };
 
diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c
index 747c043c4e2..121369e690a 100644
--- a/ext/dom/php_dom.c
+++ b/ext/dom/php_dom.c
@@ -480,7 +480,7 @@ zend_object_value dom_objects_store_clone_obj(zval *zobject TSRMLS_DC)
 	return retval;
 }
 
-static zend_function_entry dom_functions[] = {
+static const zend_function_entry dom_functions[] = {
 	PHP_FE(dom_import_simplexml, NULL)
 	{NULL, NULL, NULL}
 };
@@ -489,7 +489,7 @@ static zend_object_handlers* dom_get_obj_handlers(TSRMLS_D) {
 	return &dom_object_handlers;
 }
 
-static zend_module_dep dom_deps[] = {
+static const zend_module_dep dom_deps[] = {
 	ZEND_MOD_REQUIRED("libxml")
 	ZEND_MOD_CONFLICTS("domxml")
 	{NULL, NULL, NULL}
diff --git a/ext/dom/processinginstruction.c b/ext/dom/processinginstruction.c
index 19b4213b31f..3380e034ce9 100644
--- a/ext/dom/processinginstruction.c
+++ b/ext/dom/processinginstruction.c
@@ -35,7 +35,7 @@
 * 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}
 };
diff --git a/ext/dom/string_extend.c b/ext/dom/string_extend.c
index fd758764f0c..45a5fb08d70 100644
--- a/ext/dom/string_extend.c
+++ b/ext/dom/string_extend.c
@@ -35,7 +35,7 @@
 * 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}
diff --git a/ext/dom/text.c b/ext/dom/text.c
index 43309ae9f78..e9589f1ae3e 100644
--- a/ext/dom/text.c
+++ b/ext/dom/text.c
@@ -35,7 +35,7 @@
 * 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)
diff --git a/ext/dom/typeinfo.c b/ext/dom/typeinfo.c
index 338e58dd286..f8c3ce8db08 100644
--- a/ext/dom/typeinfo.c
+++ b/ext/dom/typeinfo.c
@@ -35,7 +35,7 @@
 * Since: DOM Level 3
 */
 
-zend_function_entry php_dom_typeinfo_class_functions[] = {
+const zend_function_entry php_dom_typeinfo_class_functions[] = {
 	{NULL, NULL, NULL}
 };
 
diff --git a/ext/dom/userdatahandler.c b/ext/dom/userdatahandler.c
index 8f5bdc00498..c9e60e4e199 100644
--- a/ext/dom/userdatahandler.c
+++ b/ext/dom/userdatahandler.c
@@ -35,7 +35,7 @@
 * 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}
 };
diff --git a/ext/dom/xpath.c b/ext/dom/xpath.c
index 2862e4a32f6..55b277dc888 100644
--- a/ext/dom/xpath.c
+++ b/ext/dom/xpath.c
@@ -36,7 +36,7 @@
 
 #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)
diff --git a/ext/ereg/ereg.c b/ext/ereg/ereg.c
index 134657dc5ba..d21d1b0c784 100644
--- a/ext/ereg/ereg.c
+++ b/ext/ereg/ereg.c
@@ -76,7 +76,7 @@ ZEND_END_ARG_INFO()
 /* }}} */
 
 /* {{{ Function table */
-zend_function_entry ereg_functions[] = {
+const zend_function_entry ereg_functions[] = {
 	PHP_FE(ereg,						arginfo_ereg)  
 	PHP_FE(ereg_replace,				arginfo_ereg_replace)
 	PHP_FE(eregi,						arginfo_eregi)
diff --git a/ext/exif/exif.c b/ext/exif/exif.c
index e896628f440..1a9b3fdca69 100644
--- a/ext/exif/exif.c
+++ b/ext/exif/exif.c
@@ -132,7 +132,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ 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)
diff --git a/ext/fbsql/php_fbsql.c b/ext/fbsql/php_fbsql.c
index b4902311ad7..a5be3845c0a 100644
--- a/ext/fbsql/php_fbsql.c
+++ b/ext/fbsql/php_fbsql.c
@@ -543,7 +543,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ 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)
diff --git a/ext/fdf/fdf.c b/ext/fdf/fdf.c
index 115ca9c3d27..2a39758de0e 100644
--- a/ext/fdf/fdf.c
+++ b/ext/fdf/fdf.c
@@ -276,7 +276,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ 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)
diff --git a/ext/filter/filter.c b/ext/filter/filter.c
index dcccd44d255..131d03a456e 100644
--- a/ext/filter/filter.c
+++ b/ext/filter/filter.c
@@ -79,7 +79,7 @@ static unsigned int php_sapi_filter(int arg, char *var, char **val, unsigned int
 
 /* {{{ 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)
diff --git a/ext/ftp/php_ftp.c b/ext/ftp/php_ftp.c
index 76733269730..76836d6286d 100644
--- a/ext/ftp/php_ftp.c
+++ b/ext/ftp/php_ftp.c
@@ -274,7 +274,7 @@ ZEND_END_ARG_INFO()
 
 /* }}} */
 
-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)
diff --git a/ext/gd/gd.c b/ext/gd/gd.c
index 19d4def7175..26f3199d60f 100644
--- a/ext/gd/gd.c
+++ b/ext/gd/gd.c
@@ -936,7 +936,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ 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)
diff --git a/ext/gettext/gettext.c b/ext/gettext/gettext.c
index 88daefa7392..92e4a9f27dd 100644
--- a/ext/gettext/gettext.c
+++ b/ext/gettext/gettext.c
@@ -101,7 +101,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ 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() */
diff --git a/ext/gmp/gmp.c b/ext/gmp/gmp.c
index c213f6dfe74..48b4f8431c0 100644
--- a/ext/gmp/gmp.c
+++ b/ext/gmp/gmp.c
@@ -278,7 +278,7 @@ static ZEND_GINIT_FUNCTION(gmp);
 
 /* {{{ 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)
diff --git a/ext/hash/hash.c b/ext/hash/hash.c
index d12899e510a..bd510ff30e1 100644
--- a/ext/hash/hash.c
+++ b/ext/hash/hash.c
@@ -856,7 +856,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ hash_functions[]
  */
-zend_function_entry hash_functions[] = {
+const zend_function_entry hash_functions[] = {
 	PHP_HASH_FE(hash)
 	PHP_HASH_FE(hash_file)
 
diff --git a/ext/iconv/iconv.c b/ext/iconv/iconv.c
index 72e7b51f3b5..9122bd2eb07 100644
--- a/ext/iconv/iconv.c
+++ b/ext/iconv/iconv.c
@@ -135,7 +135,7 @@ ZEND_END_ARG_INFO()
 
 /* {{{ 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(iconv_get_encoding,						arginfo_iconv_get_encoding)
 	PHP_FE(iconv_set_encoding,						arginfo_iconv_set_encoding)
diff --git a/ext/imap/php_imap.c b/ext/imap/php_imap.c
index 8f6f7288dcf..3ea9a8ef798 100644
--- a/ext/imap/php_imap.c
+++ b/ext/imap/php_imap.c
@@ -92,7 +92,7 @@ static PHP_GINIT_FUNCTION(imap);
 
 /* {{{ 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)
@@ -173,7 +173,7 @@ zend_function_entry imap_functions[] = {
 /* }}} */
 
 /* {{{ imap dependencies */
-static zend_module_dep imap_deps[] = {
+static const zend_module_dep imap_deps[] = {
 	ZEND_MOD_REQUIRED("standard")
 	{NULL, NULL, NULL}
 };
diff --git a/ext/interbase/interbase.c b/ext/interbase/interbase.c
index 7cc03edbf0a..74287db16a0 100644
--- a/ext/interbase/interbase.c
+++ b/ext/interbase/interbase.c
@@ -47,7 +47,7 @@ ZEND_DECLARE_MODULE_GLOBALS(ibase)
 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)
diff --git a/ext/json/json.c b/ext/json/json.c
index 6ec02898517..cd1d285692a 100644
--- a/ext/json/json.c
+++ b/ext/json/json.c
@@ -36,7 +36,7 @@ static const char digits[] = "0123456789abcdef";
  *
  * Every user visible function must have an entry in json_functions[].
  */
-function_entry json_functions[] = {
+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[] */
diff --git a/ext/ldap/ldap.c b/ext/ldap/ldap.c
index 7e942a4b2df..00a3c3510a3 100644
--- a/ext/ldap/ldap.c
+++ b/ext/ldap/ldap.c
@@ -100,7 +100,7 @@ static int le_link, le_result, le_result_entry;
 */
 /* {{{ 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)
diff --git a/ext/libxml/libxml.c b/ext/libxml/libxml.c
index ab20a21a440..7ae1f86b3c3 100644
--- a/ext/libxml/libxml.c
+++ b/ext/libxml/libxml.c
@@ -112,7 +112,7 @@ ZEND_END_ARG_INFO()
 /* }}} */
 
 /* {{{ 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)
diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c
index 9d3da33829b..ecf2f07e1e5 100644
--- a/ext/mbstring/mbstring.c
+++ b/ext/mbstring/mbstring.c
@@ -196,7 +196,7 @@ static const struct mb_overload_def mb_ovld[] = {
 /* }}} */
 
 /* {{{ 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)
diff --git a/ext/mcrypt/mcrypt.c b/ext/mcrypt/mcrypt.c
index 6cc9a679e86..0b5b89acd4f 100644
--- a/ext/mcrypt/mcrypt.c
+++ b/ext/mcrypt/mcrypt.c
@@ -44,7 +44,7 @@ typedef struct _php_mcrypt {
 	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)
diff --git a/ext/mhash/mhash.c b/ext/mhash/mhash.c
index 969d9e63a00..2441486ed6b 100644
--- a/ext/mhash/mhash.c
+++ b/ext/mhash/mhash.c
@@ -32,7 +32,7 @@
 #include "php_globals.h"
 #include "ext/standard/info.h"
 
-zend_function_entry mhash_functions[] = {
+const zend_function_entry mhash_functions[] = {
 	PHP_FE(mhash_count, NULL)
 	PHP_FE(mhash_get_block_size, NULL)
 	PHP_FE(mhash_get_hash_name, NULL)
diff --git a/ext/mime_magic/mime_magic.c b/ext/mime_magic/mime_magic.c
index 502032e1b63..e7375c68123 100644
--- a/ext/mime_magic/mime_magic.c
+++ b/ext/mime_magic/mime_magic.c
@@ -218,7 +218,7 @@ static PHP_GINIT_FUNCTION(mime_magic);
 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}	
 };
diff --git a/ext/ming/ming.c b/ext/ming/ming.c
index 07e1c1f9ef3..cc31ed9adc7 100644
--- a/ext/ming/ming.c
+++ b/ext/ming/ming.c
@@ -45,7 +45,7 @@
 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)
@@ -355,7 +355,7 @@ static SWFAction getAction(zval *id TSRMLS_DC)
 }
 /* }}} */
 
-static zend_function_entry swfaction_functions[] = {
+static const zend_function_entry swfaction_functions[] = {
 	PHP_ME(swfaction, __construct,         NULL, 0)
 	{ NULL, NULL, NULL }
 };
@@ -461,7 +461,7 @@ PHP_METHOD(swfbitmap, getHeight)
 }
 /* }}} */
 
-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)
@@ -704,7 +704,7 @@ PHP_FUNCTION(ming_keypress)
 }
 /* }}} */
 
-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)
@@ -1199,7 +1199,7 @@ PHP_METHOD(swfdisplayitem, getRot)
 /* }}} */
 #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)
@@ -1347,7 +1347,7 @@ PHP_METHOD(swffill, skewYTo)
 	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)
@@ -1412,7 +1412,7 @@ PHP_METHOD(swffontchar, addUTF8Chars)
 }
 /* }}} */
 
-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 }
@@ -1614,7 +1614,7 @@ PHP_METHOD(swffont, getShape)
 
 #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
@@ -1700,7 +1700,7 @@ PHP_METHOD(swfgradient, addEntry)
 }
 /* }}} */
 
-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 }
@@ -1769,7 +1769,7 @@ PHP_METHOD(swfmorph, getShape2)
 }
 /* }}} */
 
-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)
@@ -1849,7 +1849,7 @@ static void destroy_SWFSound_resource(zend_rsrc_list_entry *resource TSRMLS_DC)
 
 /* }}} */
 
-static zend_function_entry swfsound_functions[] = {
+static const zend_function_entry swfsound_functions[] = {
 	PHP_ME(swfsound, __construct,             NULL, 0)
 	{ NULL, NULL, NULL }
 };
@@ -1934,7 +1934,7 @@ PHP_METHOD(swfsoundinstance, loopCount)
 }
 /* }}} */
 
-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)
@@ -2038,7 +2038,7 @@ PHP_METHOD(swfvideostream, getnumframes)
 /* }}} */
 		
 		
-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)
@@ -2115,7 +2115,7 @@ static SWFPrebuiltClip getPrebuiltClip(zval *id TSRMLS_DC)
 }
 
 /* }}} */
-static zend_function_entry swfprebuiltclip_functions[] = {
+static const zend_function_entry swfprebuiltclip_functions[] = {
 	PHP_ME(swfprebuiltclip, __construct, NULL, 0)
 	{ NULL, NULL, NULL }
 };
@@ -2767,7 +2767,7 @@ PHP_METHOD(swfmovie, addFont)
 /* }}} */
 #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)
@@ -3298,7 +3298,7 @@ PHP_METHOD(swfshape, drawCubicTo)
 }
 /* }}} */
 
-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)
@@ -3489,7 +3489,7 @@ PHP_METHOD(swfsprite, stopSound)
 /* }}} */
 #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)
@@ -3775,7 +3775,7 @@ PHP_METHOD(swftext, getLeading)
 }
 /* }}} */
 
-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)
@@ -4086,7 +4086,7 @@ PHP_METHOD(swftextfield, addChars)
 /* }}} */
 #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)
diff --git a/ext/msql/php_msql.c b/ext/msql/php_msql.c
index e8d59838f9a..d4ab43f0367 100644
--- a/ext/msql/php_msql.c
+++ b/ext/msql/php_msql.c
@@ -46,7 +46,7 @@ static php_msql_globals msql_globals;
 
 /* {{{ 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)
diff --git a/ext/mssql/php_mssql.c b/ext/mssql/php_mssql.c
index 95329cd60f6..442c4702a91 100644
--- a/ext/mssql/php_mssql.c
+++ b/ext/mssql/php_mssql.c
@@ -47,7 +47,7 @@ static void php_mssql_get_column_content_without_type(mssql_link *mssql_ptr,int
 
 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)
diff --git a/ext/mysql/php_mysql.c b/ext/mysql/php_mysql.c
index 244f08e3ed6..b483c76e0a5 100644
--- a/ext/mysql/php_mysql.c
+++ b/ext/mysql/php_mysql.c
@@ -132,7 +132,7 @@ static MYSQLND_QCACHE		*mysql_mysqlnd_qcache;
 
 /* {{{ 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)
@@ -219,7 +219,7 @@ zend_function_entry mysql_functions[] = {
 /* }}} */
 
 /* Dependancies */
-static zend_module_dep mysql_deps[] = {
+static const zend_module_dep mysql_deps[] = {
 #if defined(HAVE_MYSQLND)
 	ZEND_MOD_REQUIRED("mysqlnd")
 #endif
diff --git a/ext/mysqli/mysqli.c b/ext/mysqli/mysqli.c
index ce7f7eebd11..c68ded2d7cd 100644
--- a/ext/mysqli/mysqli.c
+++ b/ext/mysqli/mysqli.c
@@ -465,7 +465,7 @@ PHP_MYSQLI_EXPORT(zend_object_value) mysqli_objects_new(zend_class_entry *class_
 
 
 /* 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
diff --git a/ext/mysqli/mysqli_driver.c b/ext/mysqli/mysqli_driver.c
index a76c782c2ee..2418bbc0b4d 100644
--- a/ext/mysqli/mysqli_driver.c
+++ b/ext/mysqli/mysqli_driver.c
@@ -154,7 +154,7 @@ mysqli_property_entry mysqli_driver_property_entries[] = {
 
 /* {{{ mysqli_driver_methods[]
  */
-zend_function_entry mysqli_driver_methods[] = {
+const zend_function_entry mysqli_driver_methods[] = {
 #if defined(HAVE_EMBEDDED_MYSQLI)
 	PHP_FALIAS(embedded_server_start, mysqli_embedded_server_start, NULL)
 	PHP_FALIAS(embedded_server_end, mysqli_embedded_server_end, NULL)
diff --git a/ext/mysqli/mysqli_exception.c b/ext/mysqli/mysqli_exception.c
index 9c00ebde8bd..6273e924fb9 100644
--- a/ext/mysqli/mysqli_exception.c
+++ b/ext/mysqli/mysqli_exception.c
@@ -32,7 +32,7 @@
 
 /* {{{ mysqli_exception_methods[]
  */
-zend_function_entry mysqli_exception_methods[] = {
+const zend_function_entry mysqli_exception_methods[] = {
 	{NULL, NULL, NULL}
 };
 /* }}} */
diff --git a/ext/mysqli/mysqli_fe.c b/ext/mysqli/mysqli_fe.c
index 965379a7047..cae2188a0ad 100644
--- a/ext/mysqli/mysqli_fe.c
+++ b/ext/mysqli/mysqli_fe.c
@@ -52,7 +52,7 @@ static
  *
  * 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)
@@ -195,7 +195,7 @@ zend_function_entry mysqli_functions[] = {
  *
  * 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)
@@ -263,7 +263,7 @@ zend_function_entry mysqli_link_methods[] = {
  *
  * 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(__construct, mysqli_result_construct, NULL)
 	PHP_FALIAS(close,mysqli_free_result,NULL)
 	PHP_FALIAS(free,mysqli_free_result,NULL)
@@ -288,7 +288,7 @@ zend_function_entry mysqli_result_methods[] = {
  *
  * 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(__construct, mysqli_stmt_construct, NULL)
 	PHP_FALIAS(attr_get,mysqli_stmt_attr_get,NULL)
 	PHP_FALIAS(attr_set,mysqli_stmt_attr_set,NULL)
diff --git a/ext/mysqli/mysqli_warning.c b/ext/mysqli/mysqli_warning.c
index e1ba41483ac..685995e20bd 100644
--- a/ext/mysqli/mysqli_warning.c
+++ b/ext/mysqli/mysqli_warning.c
@@ -313,7 +313,7 @@ PHP_METHOD(mysqli_warning, __construct)
 /* }}} */
 
 /* {{{ mysqli_warning_methods */
-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}
diff --git a/ext/mysqli/php_mysqli_structs.h b/ext/mysqli/php_mysqli_structs.h
index 447b124b4f5..0bb998ce0f8 100644
--- a/ext/mysqli/php_mysqli_structs.h
+++ b/ext/mysqli/php_mysqli_structs.h
@@ -165,13 +165,13 @@ typedef long long my_longlong;
 
 #define PHP_MYSQLI_EXPORT(__type) PHP_MYSQLI_API __type
 
-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[];
diff --git a/ext/mysqlnd/mysqlnd.c b/ext/mysqlnd/mysqlnd.c
index 02dfedb9dc6..78ac992ebb9 100644
--- a/ext/mysqlnd/mysqlnd.c
+++ b/ext/mysqlnd/mysqlnd.c
@@ -1562,7 +1562,7 @@ PHPAPI MYSQLND *mysqlnd_init(zend_bool persistent)
  *
  * Every user visible function must have an entry in mysqlnd_functions[].
  */
-static zend_function_entry mysqlnd_functions[] = {
+static const zend_function_entry mysqlnd_functions[] = {
 	{NULL, NULL, NULL}	/* Must be the last line in mysqlnd_functions[] */
 };
 /* }}} */
diff --git a/ext/oci8/oci8.c b/ext/oci8/oci8.c
index 08439a42a68..70af334c079 100644
--- a/ext/oci8/oci8.c
+++ b/ext/oci8/oci8.c
@@ -203,7 +203,7 @@ PHP_FUNCTION(oci_collection_trim);
 
 /* {{{ 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)
@@ -326,7 +326,7 @@ static zend_function_entry php_oci_functions[] = {
 	{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)
@@ -355,7 +355,7 @@ static zend_function_entry php_oci_lob_class_functions[] = {
 };
 
 #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)
diff --git a/ext/odbc/birdstep.c b/ext/odbc/birdstep.c
index 6776c7a2c4c..83b548fc7cf 100644
--- a/ext/odbc/birdstep.c
+++ b/ext/odbc/birdstep.c
@@ -49,7 +49,7 @@
 #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)
diff --git a/ext/odbc/php_odbc.c b/ext/odbc/php_odbc.c
index 20a8a1f6279..17a0a092c78 100644
--- a/ext/odbc/php_odbc.c
+++ b/ext/odbc/php_odbc.c
@@ -68,7 +68,7 @@ static int le_result, le_conn, le_pconn;
 
 /* {{{ 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)
diff --git a/ext/openssl/openssl.c b/ext/openssl/openssl.c
index 03df83f02f0..412c1bf2c1e 100644
--- a/ext/openssl/openssl.c
+++ b/ext/openssl/openssl.c
@@ -101,7 +101,7 @@ PHP_FUNCTION(openssl_dh_compute_key);
 
 /* {{{ 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)
diff --git a/ext/pcntl/pcntl.c b/ext/pcntl/pcntl.c
index f58a26dd536..462a40cc44b 100755
--- a/ext/pcntl/pcntl.c
+++ b/ext/pcntl/pcntl.c
@@ -44,7 +44,7 @@
 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)
diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c
index 16d2195ac0a..55974c7e73f 100644
--- a/ext/pcre/php_pcre.c
+++ b/ext/pcre/php_pcre.c
@@ -2006,7 +2006,7 @@ PHP_FUNCTION(preg_last_error)
 
 /* {{{ 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)
diff --git a/ext/pdo/pdo.c b/ext/pdo/pdo.c
index fca9ec1391f..519eea65b85 100755
--- a/ext/pdo/pdo.c
+++ b/ext/pdo/pdo.c
@@ -114,7 +114,7 @@ PHP_FUNCTION(pdo_drivers)
 /* }}} */
 
 /* {{{ pdo_functions[] */
-zend_function_entry pdo_functions[] = {
+const zend_function_entry pdo_functions[] = {
 	PHP_FE(pdo_drivers,             NULL)
 	{NULL, NULL, NULL}
 };
@@ -122,7 +122,7 @@ zend_function_entry pdo_functions[] = {
 
 /* {{{ 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
diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c
index d169a59f8e5..42c69606ce7 100755
--- a/ext/pdo/pdo_dbh.c
+++ b/ext/pdo/pdo_dbh.c
@@ -1137,7 +1137,7 @@ static PHP_METHOD(PDO, getAvailableDrivers)
 }
 /* }}} */
 
-zend_function_entry pdo_dbh_functions[] = {
+const zend_function_entry pdo_dbh_functions[] = {
 	ZEND_MALIAS(PDO, __construct, dbh_constructor,	NULL, 			ZEND_ACC_PUBLIC)
 	PHP_ME(PDO, prepare, 				NULL,			ZEND_ACC_PUBLIC)
 	PHP_ME(PDO, beginTransaction,		NULL,			ZEND_ACC_PUBLIC)
@@ -1160,7 +1160,7 @@ zend_function_entry pdo_dbh_functions[] = {
 /* {{{ 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;
@@ -1183,11 +1183,11 @@ int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
 	while (funcs->fname) {
 		ifunc->type = ZEND_INTERNAL_FUNCTION;
 		ifunc->handler = funcs->handler;
-		pdo_zstr_sval(ifunc->function_name) = funcs->fname;
+		pdo_zstr_sval(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;
diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c
index 9558621593e..9c2b488f75e 100755
--- a/ext/pdo/pdo_stmt.c
+++ b/ext/pdo/pdo_stmt.c
@@ -2126,7 +2126,7 @@ static PHP_METHOD(PDOStatement, __sleep)
 }
 /* }}} */
 
-zend_function_entry pdo_dbstmt_functions[] = {
+const zend_function_entry pdo_dbstmt_functions[] = {
 	PHP_ME(PDOStatement, execute,		NULL,					ZEND_ACC_PUBLIC)
 	PHP_ME(PDOStatement, fetch,			NULL,					ZEND_ACC_PUBLIC)
 	PHP_ME(PDOStatement, bindParam,		second_arg_force_ref,	ZEND_ACC_PUBLIC)
@@ -2504,7 +2504,7 @@ zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int
 
 /* {{{ 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}
 };
 
diff --git a/ext/pdo/php_pdo_driver.h b/ext/pdo/php_pdo_driver.h
index 5e61f3c2d05..4bda77a19be 100755
--- a/ext/pdo/php_pdo_driver.h
+++ b/ext/pdo/php_pdo_driver.h
@@ -289,7 +289,7 @@ enum {
 	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;
diff --git a/ext/pdo/php_pdo_int.h b/ext/pdo/php_pdo_int.h
index c60d9616262..7b83e55483b 100755
--- a/ext/pdo/php_pdo_int.h
+++ b/ext/pdo/php_pdo_int.h
@@ -32,12 +32,12 @@ void pdo_dbh_init(TSRMLS_D);
 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);
@@ -46,7 +46,7 @@ int pdo_stmt_describe_columns(pdo_stmt_t *stmt 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;
diff --git a/ext/pdo_dblib/pdo_dblib.c b/ext/pdo_dblib/pdo_dblib.c
index 5225de8d34e..4e8bc3b2118 100644
--- a/ext/pdo_dblib/pdo_dblib.c
+++ b/ext/pdo_dblib/pdo_dblib.c
@@ -35,12 +35,12 @@
 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}
 };
diff --git a/ext/pdo_firebird/pdo_firebird.c b/ext/pdo_firebird/pdo_firebird.c
index 0c6f45eed61..dcd5dbe664f 100644
--- a/ext/pdo_firebird/pdo_firebird.c
+++ b/ext/pdo_firebird/pdo_firebird.c
@@ -30,7 +30,7 @@
 #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}
 };
 /* }}} */
diff --git a/ext/pdo_mysql/pdo_mysql.c b/ext/pdo_mysql/pdo_mysql.c
index deb7f01a189..16dc11f78f2 100755
--- a/ext/pdo_mysql/pdo_mysql.c
+++ b/ext/pdo_mysql/pdo_mysql.c
@@ -31,14 +31,14 @@
 #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}
 };
diff --git a/ext/pdo_oci/pdo_oci.c b/ext/pdo_oci/pdo_oci.c
index 29836725929..f73d3734457 100755
--- a/ext/pdo_oci/pdo_oci.c
+++ b/ext/pdo_oci/pdo_oci.c
@@ -31,7 +31,7 @@
 #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}
 };
 /* }}} */
@@ -39,7 +39,7 @@ zend_function_entry pdo_oci_functions[] = {
 /* {{{ 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}
 };
diff --git a/ext/pdo_odbc/pdo_odbc.c b/ext/pdo_odbc/pdo_odbc.c
index ed12c7bf632..924853fa094 100755
--- a/ext/pdo_odbc/pdo_odbc.c
+++ b/ext/pdo_odbc/pdo_odbc.c
@@ -31,14 +31,14 @@
 #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}
 };
diff --git a/ext/pdo_pgsql/pdo_pgsql.c b/ext/pdo_pgsql/pdo_pgsql.c
index 4f75bff72ea..c8f8ef3c5b2 100644
--- a/ext/pdo_pgsql/pdo_pgsql.c
+++ b/ext/pdo_pgsql/pdo_pgsql.c
@@ -40,7 +40,7 @@
 #endif
 
 /* {{{ pdo_pgsql_functions[] */
-zend_function_entry pdo_pgsql_functions[] = {
+const zend_function_entry pdo_pgsql_functions[] = {
 	{NULL, NULL, NULL}
 };
 /* }}} */
@@ -48,7 +48,7 @@ zend_function_entry pdo_pgsql_functions[] = {
 /* {{{ 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}
 };
diff --git a/ext/pdo_sqlite/pdo_sqlite.c b/ext/pdo_sqlite/pdo_sqlite.c
index 937f4011596..f7a58daa675 100644
--- a/ext/pdo_sqlite/pdo_sqlite.c
+++ b/ext/pdo_sqlite/pdo_sqlite.c
@@ -34,7 +34,7 @@
 #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}
 };
 /* }}} */
@@ -42,7 +42,7 @@ zend_function_entry pdo_sqlite_functions[] = {
 /* {{{ 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}
 };
diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c
index d06559ea8ac..5afb51d9cf9 100644
--- a/ext/pdo_sqlite/sqlite_driver.c
+++ b/ext/pdo_sqlite/sqlite_driver.c
@@ -609,13 +609,13 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 	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:
diff --git a/ext/pgsql/pgsql.c b/ext/pgsql/pgsql.c
index 61fd703b90a..34ff1031984 100644
--- a/ext/pgsql/pgsql.c
+++ b/ext/pgsql/pgsql.c
@@ -91,7 +91,7 @@ static PHP_GINIT_FUNCTION(pgsql);
 
 /* {{{ 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)
diff --git a/ext/posix/posix.c b/ext/posix/posix.c
index 5d43434c9cd..02188eb29f3 100644
--- a/ext/posix/posix.c
+++ b/ext/posix/posix.c
@@ -53,7 +53,7 @@ static PHP_MINFO_FUNCTION(posix);
 
 /* {{{ posix_functions[]
  */
-zend_function_entry posix_functions[] = {
+const zend_function_entry posix_functions[] = {
     /* POSIX.1, 3.3 */
 	PHP_FE(posix_kill,		NULL)
 
diff --git a/ext/pspell/pspell.c b/ext/pspell/pspell.c
index 95ba28c0573..e457a2430b9 100644
--- a/ext/pspell/pspell.c
+++ b/ext/pspell/pspell.c
@@ -74,7 +74,7 @@ static PHP_FUNCTION(pspell_config_save_repl);
 
 /* {{{ pspell_functions[]
  */
-zend_function_entry pspell_functions[] = {
+const zend_function_entry pspell_functions[] = {
 	PHP_FE(pspell_new,		NULL)
 	PHP_FE(pspell_new_personal,		NULL)
 	PHP_FE(pspell_new_config,		NULL)
diff --git a/ext/readline/readline.c b/ext/readline/readline.c
index 1bae0f6ec95..3ca511ad048 100644
--- a/ext/readline/readline.c
+++ b/ext/readline/readline.c
@@ -69,7 +69,7 @@ PHP_RSHUTDOWN_FUNCTION(readline);
 /* }}} */
 /* {{{ 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)
diff --git a/ext/recode/recode.c b/ext/recode/recode.c
index 902fce9e55f..5804e8b40e5 100644
--- a/ext/recode/recode.c
+++ b/ext/recode/recode.c
@@ -67,7 +67,7 @@ ZEND_DECLARE_MODULE_GLOBALS(recode);
 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)
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index 6ed15776d38..0a402f6cb87 100644
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -926,7 +926,7 @@ static void _extension_string(string *str, zend_module_entry *module, char *inde
 				  (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");
 
@@ -988,7 +988,7 @@ static void _extension_string(string *str, zend_module_entry *module, char *inde
 
 	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");
 
@@ -1058,7 +1058,7 @@ PHPAPI void zend_reflection_class_factory(zend_class_entry *ce, zval *object TSR
 /* }}} */
 
 /* {{{ 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;
@@ -4322,7 +4322,7 @@ ZEND_METHOD(reflection_extension, getFunctions)
 	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) {
@@ -4466,7 +4466,7 @@ ZEND_METHOD(reflection_extension, getDependencies)
 {
 	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);
@@ -4527,7 +4527,7 @@ ZEND_METHOD(reflection_extension, info)
 /* }}} */
 
 /* {{{ method tables */
-static zend_function_entry reflection_exception_functions[] = {
+static const zend_function_entry reflection_exception_functions[] = {
 	{NULL, NULL, NULL}
 };
 
@@ -4543,13 +4543,13 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_reflection_export, 0, 0, 1)
 	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}
@@ -4576,7 +4576,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_reflection_function_invokeArgs, 0)
 	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)
@@ -4597,7 +4597,7 @@ static zend_function_entry reflection_function_abstract_functions[] = {
 	{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)
@@ -4632,7 +4632,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_reflection_method_invokeArgs, 0)
 	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)
@@ -4741,7 +4741,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_reflection_class_implementsInterface, 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)
@@ -4798,7 +4798,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_reflection_object___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}
@@ -4827,7 +4827,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_reflection_property_setValue, 0)
 	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)
@@ -4860,7 +4860,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_reflection_parameter___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)
@@ -4890,7 +4890,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_reflection_extension___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)
@@ -4908,7 +4908,7 @@ static zend_function_entry reflection_extension_functions[] = {
 };
 /* }}} */
 
-zend_function_entry reflection_ext_functions[] = { /* {{{ */
+const zend_function_entry reflection_ext_functions[] = { /* {{{ */
 	{NULL, NULL, NULL}
 }; /* }}} */
 
diff --git a/ext/session/session.c b/ext/session/session.c
index 38c69e0864f..5b8885e69b0 100644
--- a/ext/session/session.c
+++ b/ext/session/session.c
@@ -597,7 +597,7 @@ static PHP_INI_MH(OnUpdateHashFunc)
 
 #if defined(HAVE_HASH_EXT) && !defined(COMPILE_DL_HASH)
 {
-	php_hash_ops *ops = php_hash_fetch_ops(new_value, new_value_length);
+	php_hash_ops *ops = (php_hash_ops*)php_hash_fetch_ops(new_value, new_value_length);
 
 	if (ops) {
 		PS(hash_func) = PS_HASH_FUNC_OTHER;
@@ -1774,7 +1774,7 @@ static PHP_FUNCTION(session_write_close)
 
 /* {{{ session_functions[]
  */
-static zend_function_entry session_functions[] = {
+static const zend_function_entry session_functions[] = {
 	PHP_FE(session_name,              NULL)
 	PHP_FE(session_module_name,       NULL)
 	PHP_FE(session_save_path,         NULL)
diff --git a/ext/shmop/shmop.c b/ext/shmop/shmop.c
index 8051e2f84bd..a56f2cd54aa 100644
--- a/ext/shmop/shmop.c
+++ b/ext/shmop/shmop.c
@@ -47,7 +47,7 @@ int shm_type;
 
 /* {{{ 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)
diff --git a/ext/simplexml/simplexml.c b/ext/simplexml/simplexml.c
index 69a0e9dc931..50fe65bafdd 100644
--- a/ext/simplexml/simplexml.c
+++ b/ext/simplexml/simplexml.c
@@ -2412,14 +2412,14 @@ PHP_FUNCTION(simplexml_import_dom)
 }
 /* }}} */
 
-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}
 };
@@ -2444,7 +2444,7 @@ ZEND_GET_MODULE(simplexml)
 
 /* 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)
diff --git a/ext/skeleton/skeleton.c b/ext/skeleton/skeleton.c
index 08868874e84..42685757da8 100644
--- a/ext/skeleton/skeleton.c
+++ b/ext/skeleton/skeleton.c
@@ -20,7 +20,7 @@ static int le_extname;
  *
  * 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[] */
diff --git a/ext/snmp/snmp.c b/ext/snmp/snmp.c
index 2cf9162e9ec..7bc0eb75f04 100644
--- a/ext/snmp/snmp.c
+++ b/ext/snmp/snmp.c
@@ -114,7 +114,7 @@ static oid objid_mib[] = {1, 3, 6, 1, 2, 1};
 
 /* {{{ 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)
diff --git a/ext/snmp/winsnmp.c b/ext/snmp/winsnmp.c
index 7aa4866d43b..331a116e74b 100644
--- a/ext/snmp/winsnmp.c
+++ b/ext/snmp/winsnmp.c
@@ -21,7 +21,7 @@ Created from the snmputil sample in the Microsoft SDK for NT
 
 /* {{{ snmp_functions[]
  */
-zend_function_entry snmp_functions[] = {
+const zend_function_entry snmp_functions[] = {
     {"snmpget", php3_snmpget, NULL},
     {"snmpwalk", php3_snmpwalk, NULL},
     {NULL,NULL,NULL}
diff --git a/ext/soap/soap.c b/ext/soap/soap.c
index d7043d279f7..725d5d46a5d 100644
--- a/ext/soap/soap.c
+++ b/ext/soap/soap.c
@@ -203,19 +203,19 @@ PHP_METHOD(SoapHeader, SoapHeader);
 
 #define SOAP_CTOR(class_name, func_name, arginfo, flags) ZEND_FENTRY(__construct, ZEND_MN(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)
 	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)
@@ -240,7 +240,7 @@ ZEND_BEGIN_ARG_INFO_EX(__soap_call_args, 0, 0, 2)
 	ZEND_ARG_PASS_INFO(1)
 ZEND_END_ARG_INFO()
 
-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_FENTRY(__soapCall, ZEND_MN(SoapClient___call), __soap_call_args, 0)
@@ -258,17 +258,17 @@ static zend_function_entry soap_client_functions[] = {
 	{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}
 };
diff --git a/ext/sockets/sockets.c b/ext/sockets/sockets.c
index c7b78c839eb..1b8c0738bfe 100644
--- a/ext/sockets/sockets.c
+++ b/ext/sockets/sockets.c
@@ -120,7 +120,7 @@ static
 
 /* {{{ 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)
diff --git a/ext/spl/php_spl.c b/ext/spl/php_spl.c
index 8fd6d9313f5..23c26db5187 100755
--- a/ext/spl/php_spl.c
+++ b/ext/spl/php_spl.c
@@ -47,7 +47,7 @@ ZEND_DECLARE_MODULE_GLOBALS(spl)
 
 /* {{{ spl_functions_none
  */
-zend_function_entry spl_functions_none[] = {
+const zend_function_entry spl_functions_none[] = {
 	{NULL, NULL, NULL}
 };
 /* }}} */
@@ -718,7 +718,7 @@ ZEND_END_ARG_INFO();
 
 /* {{{ 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)
@@ -777,7 +777,7 @@ PHP_RSHUTDOWN_FUNCTION(spl) /* {{{ */
 } /* }}} */
 
 #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}
diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c
index 51d9336de54..da554af5f95 100755
--- a/ext/spl/spl_array.c
+++ b/ext/spl/spl_array.c
@@ -1466,7 +1466,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_array_uXsort, 0)
 	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)
@@ -1491,7 +1491,7 @@ static zend_function_entry spl_funcs_ArrayObject[] = {
 	{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)
@@ -1518,7 +1518,7 @@ static zend_function_entry spl_funcs_ArrayIterator[] = {
 	{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}
diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c
index 53d3e88340e..42ea7186856 100755
--- a/ext/spl/spl_directory.c
+++ b/ext/spl/spl_directory.c
@@ -1595,7 +1595,7 @@ ZEND_END_ARG_INFO()
 
 /* 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)
@@ -1637,7 +1637,7 @@ ZEND_END_ARG_INFO()
 
 /* 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)
@@ -1663,7 +1663,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_r_dir_hasChildren, 0, 0, 0)
 	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)
@@ -2472,7 +2472,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_file_object_seek, 0, 0, 1)
 	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)
@@ -2513,7 +2513,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_temp_file_object___construct, 0, 0, 0)
 	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}
 };
diff --git a/ext/spl/spl_functions.c b/ext/spl/spl_functions.c
index 8de74714e7a..071f2b6199f 100755
--- a/ext/spl/spl_functions.c
+++ b/ext/spl/spl_functions.c
@@ -36,7 +36,7 @@ void spl_destroy_class(zend_class_entry ** ppce)
 /* }}} */
 
 /* {{{ 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;
 	
@@ -46,7 +46,7 @@ void spl_register_interface(zend_class_entry ** ppce, char * class_name, zend_fu
 /* }}} */
 
 /* {{{ 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;
 	
@@ -61,7 +61,7 @@ PHPAPI void spl_register_std_class(zend_class_entry ** ppce, char * class_name,
 /* }}} */
 
 /* {{{ 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;
 	
@@ -85,7 +85,7 @@ void spl_register_parent_ce(zend_class_entry * class_entry, zend_class_entry * p
 /* }}} */
 
 /* {{{ 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);
 }
diff --git a/ext/spl/spl_functions.h b/ext/spl/spl_functions.h
index 286b1fb2193..be423e67c26 100755
--- a/ext/spl/spl_functions.h
+++ b/ext/spl/spl_functions.h
@@ -57,13 +57,13 @@ typedef zend_object_value (*create_object_func_t)(zend_class_entry *class_type T
 
 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
diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c
index 719c81decdf..8fb31f8e6e6 100755
--- a/ext/spl/spl_iterators.c
+++ b/ext/spl/spl_iterators.c
@@ -59,7 +59,7 @@ PHPAPI zend_class_entry *spl_ce_RegexIterator;
 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}
@@ -774,7 +774,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_recursive_it_setMaxDepth, 0, 0, 0)
 	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)
@@ -1642,7 +1642,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_filter_it___construct, 0)
 	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)
@@ -1659,14 +1659,14 @@ ZEND_BEGIN_ARG_INFO(arginfo_parent_it___construct, 0)
 	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}
@@ -1697,7 +1697,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_regex_it_set_preg_flags, 0, 0, 1)
 	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)
@@ -1718,7 +1718,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_rec_regex_it___construct, 0, 0, 2)
 	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)
@@ -1850,7 +1850,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_seekable_it_seek, 0)
 	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}
 };
@@ -1867,7 +1867,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_limit_it_seek, 0)
 	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)
@@ -2277,7 +2277,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_caching_it_offsetSet, 0)
 	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)
@@ -2337,7 +2337,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_caching_rec_it___construct, 0, ZEND_RETURN_VALUE,
 	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)
@@ -2356,7 +2356,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_iterator_it___construct, 0)
 	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)
@@ -2448,7 +2448,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_norewind_it___construct, 0)
 	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)
@@ -2485,7 +2485,7 @@ SPL_METHOD(InfiniteIterator, next)
 	}
 } /* }}} */
 
-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}
@@ -2524,7 +2524,7 @@ SPL_METHOD(EmptyIterator, next)
 {
 } /* }}} */
 
-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)
@@ -2681,7 +2681,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_append_it_append, 0)
 	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)
@@ -2876,12 +2876,12 @@ PHP_FUNCTION(iterator_apply)
 }
 /* }}} */
 
-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}
 };
diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c
index 80071af2da5..c926dc0be6c 100755
--- a/ext/spl/spl_observer.c
+++ b/ext/spl/spl_observer.c
@@ -48,7 +48,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_SplObserver_update, 0)
 	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}
 };
@@ -63,7 +63,7 @@ ZEND_BEGIN_ARG_INFO_EX(arginfo_SplSubject_notify, 0, 0, 1)
 	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)
@@ -451,7 +451,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_Serialized, 0)
 	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)
diff --git a/ext/spl/spl_sxe.c b/ext/spl/spl_sxe.c
index a2cb7ff9130..8ec2f823e18 100755
--- a/ext/spl/spl_sxe.c
+++ b/ext/spl/spl_sxe.c
@@ -156,7 +156,7 @@ SPL_METHOD(SimpleXMLIterator, count)
 	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)
diff --git a/ext/sqlite/pdo_sqlite2.c b/ext/sqlite/pdo_sqlite2.c
index 10bb3b43545..2c1048205ed 100644
--- a/ext/sqlite/pdo_sqlite2.c
+++ b/ext/sqlite/pdo_sqlite2.c
@@ -486,12 +486,12 @@ static PHP_FUNCTION(sqlite2_create_function)
 	/* 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:
diff --git a/ext/sqlite/sqlite.c b/ext/sqlite/sqlite.c
index babcf8fcd4a..b29c56cca20 100644
--- a/ext/sqlite/sqlite.c
+++ b/ext/sqlite/sqlite.c
@@ -210,7 +210,7 @@ static int php_sqlite_fetch(struct php_sqlite_result *rres TSRMLS_DC);
 
 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)
@@ -253,7 +253,7 @@ zend_function_entry sqlite_functions[] = {
 	{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)
@@ -273,7 +273,7 @@ zend_function_entry sqlite_funcs_db[] = {
 	{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)
@@ -297,7 +297,7 @@ zend_function_entry sqlite_funcs_query[] = {
 	{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)
@@ -312,12 +312,12 @@ zend_function_entry sqlite_funcs_ub_query[] = {
 	{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
diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c
index 45106f1cb12..31bbee8d410 100644
--- a/ext/standard/basic_functions.c
+++ b/ext/standard/basic_functions.c
@@ -3089,7 +3089,7 @@ ZEND_END_ARG_INFO()
 /* }}} */
 /* }}} */
 
-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)
@@ -3774,7 +3774,7 @@ zend_function_entry basic_functions[] = { /* {{{ */
 };
 /* }}} */
 
-static zend_module_dep standard_deps[] = { /* {{{ */
+static const zend_module_dep standard_deps[] = { /* {{{ */
 	ZEND_MOD_OPTIONAL("session")
 	{NULL, NULL, NULL}
 };
diff --git a/ext/standard/dir.c b/ext/standard/dir.c
index 07a3df957a9..803331c267e 100644
--- a/ext/standard/dir.c
+++ b/ext/standard/dir.c
@@ -93,7 +93,7 @@ static zend_class_entry *dir_class_entry_ptr;
 			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)
diff --git a/ext/standard/dl.c b/ext/standard/dl.c
index 6765087c17f..95b2477948d 100644
--- a/ext/standard/dl.c
+++ b/ext/standard/dl.c
@@ -191,7 +191,7 @@ void php_dl(zval *file, int type, zval *return_value, int start_now TSRMLS_DC)
 				  unsigned int zend_api;
 			};
 
-			char *name;
+			const char *name;
 			int zend_api;
 			unsigned char zend_debug, zts;
 
diff --git a/ext/standard/info.c b/ext/standard/info.c
index 11e58342f48..0eadc51f5c8 100644
--- a/ext/standard/info.c
+++ b/ext/standard/info.c
@@ -967,7 +967,7 @@ PHP_FUNCTION(phpversion)
 	if (!ext_name) {
 		RETURN_ASCII_STRING(PHP_VERSION, 1);
 	} else {
-		char *version;
+		const char *version;
 		version = zend_get_module_version(ext_name);
 		if (version == NULL) {
 			RETURN_FALSE;
diff --git a/ext/standard/user_filters.c b/ext/standard/user_filters.c
index 9c40db5df73..27966f748c4 100644
--- a/ext/standard/user_filters.c
+++ b/ext/standard/user_filters.c
@@ -75,7 +75,7 @@ static
 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)
diff --git a/ext/sybase/php_sybase_db.c b/ext/sybase/php_sybase_db.c
index ebf8956db3e..a7da813c3ed 100644
--- a/ext/sybase/php_sybase_db.c
+++ b/ext/sybase/php_sybase_db.c
@@ -81,7 +81,7 @@ typedef struct {
 } 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)
diff --git a/ext/sybase_ct/php_sybase_ct.c b/ext/sybase_ct/php_sybase_ct.c
index a9e8752e0dd..c1d5480c3e8 100644
--- a/ext/sybase_ct/php_sybase_ct.c
+++ b/ext/sybase_ct/php_sybase_ct.c
@@ -41,7 +41,7 @@ ZEND_DECLARE_MODULE_GLOBALS(sybase)
 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)
diff --git a/ext/sysvmsg/sysvmsg.c b/ext/sysvmsg/sysvmsg.c
index c81754257d8..ca761016414 100644
--- a/ext/sysvmsg/sysvmsg.c
+++ b/ext/sysvmsg/sysvmsg.c
@@ -66,7 +66,7 @@ static
  *
  * 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)
diff --git a/ext/sysvsem/sysvsem.c b/ext/sysvsem/sysvsem.c
index c8f279d612c..fd2a1330b19 100644
--- a/ext/sysvsem/sysvsem.c
+++ b/ext/sysvsem/sysvsem.c
@@ -58,7 +58,7 @@ union semun {
 
 /* {{{ 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)
diff --git a/ext/sysvshm/sysvshm.c b/ext/sysvshm/sysvshm.c
index d23e20f9709..ae3b828e0ed 100644
--- a/ext/sysvshm/sysvshm.c
+++ b/ext/sysvshm/sysvshm.c
@@ -41,7 +41,7 @@
 
 /* {{{ 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)
diff --git a/ext/tidy/tidy.c b/ext/tidy/tidy.c
index 83abefff5a1..9f0bedaaa4f 100644
--- a/ext/tidy/tidy.c
+++ b/ext/tidy/tidy.c
@@ -286,7 +286,7 @@ STD_PHP_INI_ENTRY("tidy.default_config",	"",		PHP_INI_SYSTEM,		OnUpdateString,
 STD_PHP_INI_ENTRY("tidy.clean_output",		"0",	PHP_INI_USER,		php_tidy_set_clean_output,	clean_output,		zend_tidy_globals,	tidy_globals)
 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)
@@ -316,7 +316,7 @@ static zend_function_entry tidy_functions[] = {
 	{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)
@@ -341,7 +341,7 @@ static zend_function_entry tidy_funcs_doc[] = {
 	{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)
diff --git a/ext/tokenizer/tokenizer.c b/ext/tokenizer/tokenizer.c
index 3de5616f620..c0c34d43d5d 100644
--- a/ext/tokenizer/tokenizer.c
+++ b/ext/tokenizer/tokenizer.c
@@ -97,7 +97,7 @@ struct yy_buffer_state
  *
  * 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[] */
diff --git a/ext/unicode/collator.c b/ext/unicode/collator.c
index 9dbd7276457..e3d420d9dd4 100644
--- a/ext/unicode/collator.c
+++ b/ext/unicode/collator.c
@@ -24,7 +24,7 @@
 #include <unicode/ucol.h>
 
 
-zend_function_entry collator_funcs_collator[] = {
+const zend_function_entry collator_funcs_collator[] = {
 	ZEND_ME(collator, __construct, NULL, ZEND_ACC_PUBLIC)
 	ZEND_FENTRY(getDefault, 	ZEND_FN(collator_get_default), NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
 	ZEND_FENTRY(setDefault, 	ZEND_FN(collator_set_default), NULL, ZEND_ACC_PUBLIC|ZEND_ACC_STATIC)
diff --git a/ext/unicode/unicode.c b/ext/unicode/unicode.c
index 2f130dcb2d6..ade1704a9de 100644
--- a/ext/unicode/unicode.c
+++ b/ext/unicode/unicode.c
@@ -299,7 +299,7 @@ PHP_FUNCTION(unicode_restore_error_handler)
 /* }}} */
 
 /* {{{ unicode_functions[] */
-zend_function_entry unicode_functions[] = {
+const zend_function_entry unicode_functions[] = {
 	PHP_FE(locale_get_default, NULL)
 	PHP_FE(locale_set_default, NULL)
 	PHP_FE(unicode_decode, NULL)
diff --git a/ext/unicode/unicode_iterators.c b/ext/unicode/unicode_iterators.c
index 7ad6f746fc3..aaf060bbf34 100644
--- a/ext/unicode/unicode_iterators.c
+++ b/ext/unicode/unicode_iterators.c
@@ -1364,7 +1364,7 @@ PHP_METHOD(TextIterator, getAll)
 /* }}} */
 
 /* {{{ TextIterator function entry table */
-static zend_function_entry text_iterator_funcs[] = {
+static const zend_function_entry text_iterator_funcs[] = {
 
 	PHP_ME(TextIterator, __construct, NULL, ZEND_ACC_PUBLIC)
 
diff --git a/ext/wddx/wddx.c b/ext/wddx/wddx.c
index 0c1aedf1eb6..1954b371645 100644
--- a/ext/wddx/wddx.c
+++ b/ext/wddx/wddx.c
@@ -104,7 +104,7 @@ static void php_wddx_process_data(void *user_data, const XML_Char *s, int len);
 
 /* {{{ 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)
diff --git a/ext/xml/xml.c b/ext/xml/xml.c
index 58a1083cd0d..2cda61a1657 100644
--- a/ext/xml/xml.c
+++ b/ext/xml/xml.c
@@ -107,7 +107,7 @@ static
 		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)
@@ -136,7 +136,7 @@ zend_function_entry xml_functions[] = {
 };
 
 #ifdef LIBXML_EXPAT_COMPAT
-static zend_module_dep xml_deps[] = {
+static const zend_module_dep xml_deps[] = {
 	ZEND_MOD_REQUIRED("libxml")
 	{NULL, NULL, NULL}
 };
diff --git a/ext/xmlreader/php_xmlreader.c b/ext/xmlreader/php_xmlreader.c
index 9922c1a23df..0257ea5b5bc 100644
--- a/ext/xmlreader/php_xmlreader.c
+++ b/ext/xmlreader/php_xmlreader.c
@@ -320,7 +320,7 @@ static xmlRelaxNGPtr _xmlreader_get_relaxNG(char *source, int source_len, int ty
 #endif
 
 #if ZEND_MODULE_API_NO >= 20050922
-static zend_module_dep xmlreader_deps[] = {
+static const zend_module_dep xmlreader_deps[] = {
 	ZEND_MOD_REQUIRED("libxml")
 	{NULL, NULL, NULL}
 };
@@ -1337,7 +1337,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_xmlreader_expand, 0)
 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)
diff --git a/ext/xmlrpc/xmlrpc-epi-php.c b/ext/xmlrpc/xmlrpc-epi-php.c
index a49448f224c..8209dd43397 100644
--- a/ext/xmlrpc/xmlrpc-epi-php.c
+++ b/ext/xmlrpc/xmlrpc-epi-php.c
@@ -75,7 +75,7 @@
 
 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)
diff --git a/ext/xmlwriter/php_xmlwriter.c b/ext/xmlwriter/php_xmlwriter.c
index 83d0de6dd0b..a76ebaf963b 100644
--- a/ext/xmlwriter/php_xmlwriter.c
+++ b/ext/xmlwriter/php_xmlwriter.c
@@ -173,7 +173,7 @@ static zend_object_value xmlwriter_object_new(zend_class_entry *class_type TSRML
 	}	\
 
 /* {{{ 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
@@ -234,7 +234,7 @@ static zend_function_entry xmlwriter_functions[] = {
 #define PHP_ME_MAPPING(name, func_name, arg_types, flags) ZEND_ME_MAPPING(name, func_name, arg_types)
 #endif
 /* {{{ 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
diff --git a/ext/xsl/php_xsl.c b/ext/xsl/php_xsl.c
index 7d4f83989d6..2bc8e058830 100644
--- a/ext/xsl/php_xsl.c
+++ b/ext/xsl/php_xsl.c
@@ -35,12 +35,12 @@ static zend_object_handlers xsl_object_handlers;
  *
  * 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}
 };
diff --git a/ext/xsl/xsl_fe.h b/ext/xsl/xsl_fe.h
index a6e992ea231..eb8ea06e426 100644
--- a/ext/xsl/xsl_fe.h
+++ b/ext/xsl/xsl_fe.h
@@ -21,8 +21,8 @@
 #ifndef XSL_FE_H
 #define XSL_FE_H
 
-extern zend_function_entry php_xsl_xsltprocessor_class_functions[];
-extern zend_class_entry *xsl_xsltprocessor_class_entry;
+extern const zend_function_entry php_xsl_xsltprocessor_class_functions[];
+extern const zend_class_entry *xsl_xsltprocessor_class_entry;
 
 PHP_FUNCTION(xsl_xsltprocessor_import_stylesheet);
 PHP_FUNCTION(xsl_xsltprocessor_transform_to_doc);
diff --git a/ext/xsl/xsltprocessor.c b/ext/xsl/xsltprocessor.c
index 3d16d4136f0..a3f62bc60a2 100644
--- a/ext/xsl/xsltprocessor.c
+++ b/ext/xsl/xsltprocessor.c
@@ -34,7 +34,7 @@
 * 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)
diff --git a/ext/zip/php_zip.c b/ext/zip/php_zip.c
index 5609b8919c7..e443e16035c 100644
--- a/ext/zip/php_zip.c
+++ b/ext/zip/php_zip.c
@@ -272,7 +272,7 @@ static char * php_zipobj_get_zip_comment(struct zip *za, int *len TSRMLS_DC) /*
 /* }}} */
 
 /* {{{ 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)
@@ -2065,7 +2065,7 @@ static ZIPARCHIVE_METHOD(getStream)
 /* }}} */
 
 /* {{{ 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)
diff --git a/ext/zlib/zlib.c b/ext/zlib/zlib.c
index 392b7a95f44..025657dc3ed 100644
--- a/ext/zlib/zlib.c
+++ b/ext/zlib/zlib.c
@@ -608,7 +608,7 @@ ZEND_GET_MODULE(php_zlib)
 #endif
 
 /* {{{ php_zlib_functions[] */
-zend_function_entry php_zlib_functions[] = {
+const zend_function_entry php_zlib_functions[] = {
 	PHP_FE(readgzfile,						NULL)
 	PHP_FALIAS(gzrewind,	rewind,			NULL)
 	PHP_FALIAS(gzclose,		fclose,			NULL)
diff --git a/main/SAPI.h b/main/SAPI.h
index 21eb8d5c1b5..b719016036d 100644
--- a/main/SAPI.h
+++ b/main/SAPI.h
@@ -260,7 +260,7 @@ struct _sapi_module_struct {
 	int phpinfo_as_text;
 
 	char *ini_entries;
-	zend_function_entry *additional_functions;
+	const zend_function_entry *additional_functions;
 };
 
 
diff --git a/sapi/aolserver/aolserver.c b/sapi/aolserver/aolserver.c
index 37bb5aab297..0b432f3e4ab 100644
--- a/sapi/aolserver/aolserver.c
+++ b/sapi/aolserver/aolserver.c
@@ -240,7 +240,7 @@ static void php_info_aolserver(ZEND_MODULE_INFO_FUNC_ARGS)
 
 PHP_FUNCTION(getallheaders);
 
-static zend_function_entry aolserver_functions[] = {
+static const zend_function_entry aolserver_functions[] = {
 	PHP_FE(getallheaders, NULL)
 	{NULL, NULL, NULL}
 };
diff --git a/sapi/apache/php_apache.c b/sapi/apache/php_apache.c
index 868c4c3d9da..e5e3d3eba80 100644
--- a/sapi/apache/php_apache.c
+++ b/sapi/apache/php_apache.c
@@ -56,7 +56,7 @@ PHP_FUNCTION(apache_reset_timeout);
 
 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)
diff --git a/sapi/apache2filter/php_functions.c b/sapi/apache2filter/php_functions.c
index 93402048164..b96a08d417f 100644
--- a/sapi/apache2filter/php_functions.c
+++ b/sapi/apache2filter/php_functions.c
@@ -359,7 +359,7 @@ PHP_MINFO_FUNCTION(apache)
 	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)
diff --git a/sapi/apache2handler/php_functions.c b/sapi/apache2handler/php_functions.c
index 277046b33b5..e7a33c602c4 100644
--- a/sapi/apache2handler/php_functions.c
+++ b/sapi/apache2handler/php_functions.c
@@ -478,7 +478,7 @@ PHP_MINFO_FUNCTION(apache)
 	}
 }
 
-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)
diff --git a/sapi/apache_hooks/php_apache.c b/sapi/apache_hooks/php_apache.c
index c14bc722ef0..fcc5b0578bb 100644
--- a/sapi/apache_hooks/php_apache.c
+++ b/sapi/apache_hooks/php_apache.c
@@ -60,7 +60,7 @@ PHP_FUNCTION(apache_get_modules);
 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)
@@ -1286,7 +1286,7 @@ PHP_FUNCTION(apache_request_send_header_field)
 
 /* {{{ php_apache_request_class_functions
  */
-static zend_function_entry php_apache_request_class_functions[] = {
+static const zend_function_entry php_apache_request_class_functions[] = {
 	/* string slots */
 	PHP_FALIAS(args,						apache_request_args,				NULL)
 	PHP_FALIAS(boundary,					apache_request_boundary,			NULL)
diff --git a/sapi/cgi/cgi_main.c b/sapi/cgi/cgi_main.c
index afddf75a507..ee6712c00d2 100644
--- a/sapi/cgi/cgi_main.c
+++ b/sapi/cgi/cgi_main.c
@@ -623,7 +623,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_dl, 0)
 ZEND_END_ARG_INFO()
 /* }}} */
 
-static zend_function_entry additional_functions[] = {
+static const zend_function_entry additional_functions[] = {
 	ZEND_FE(dl, arginfo_dl)
 	{NULL, NULL, NULL}
 };
diff --git a/sapi/cli/php_cli.c b/sapi/cli/php_cli.c
index 5fe2a91484e..7b8e096620e 100644
--- a/sapi/cli/php_cli.c
+++ b/sapi/cli/php_cli.c
@@ -415,7 +415,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_dl, 0)
 ZEND_END_ARG_INFO()
 /* }}} */
 
-static zend_function_entry additional_functions[] = {
+static const zend_function_entry additional_functions[] = {
 	ZEND_FE(dl, arginfo_dl)
 	{NULL, NULL, NULL}
 };
diff --git a/sapi/continuity/capi.c b/sapi/continuity/capi.c
index cb99b86171e..e1fc659e43d 100644
--- a/sapi/continuity/capi.c
+++ b/sapi/continuity/capi.c
@@ -80,7 +80,7 @@ PHP_FUNCTION(continuity_virtual);
 PHP_FUNCTION(continuity_request_headers);
 PHP_FUNCTION(continuity_response_headers);
 
-zend_function_entry continuity_functions[] = {
+const zend_function_entry continuity_functions[] = {
         {NULL, NULL, NULL}
 };
 
diff --git a/sapi/embed/php_embed.c b/sapi/embed/php_embed.c
index c2469e6eb64..53316ad2b7c 100644
--- a/sapi/embed/php_embed.c
+++ b/sapi/embed/php_embed.c
@@ -146,7 +146,7 @@ ZEND_BEGIN_ARG_INFO(arginfo_dl, 0)
 ZEND_END_ARG_INFO()
 /* }}} */
 
-static zend_function_entry additional_functions[] = {
+static const zend_function_entry additional_functions[] = {
 	ZEND_FE(dl, arginfo_dl)
 	{NULL, NULL, NULL}
 };
diff --git a/sapi/milter/php_milter.c b/sapi/milter/php_milter.c
index 373d7fd70d9..5c6e393c4f6 100644
--- a/sapi/milter/php_milter.c
+++ b/sapi/milter/php_milter.c
@@ -770,7 +770,7 @@ PHP_MINFO_FUNCTION(milter)
 
 /* {{{ milter_functions[]
 */
-static zend_function_entry milter_functions[] = {
+static const zend_function_entry milter_functions[] = {
 	PHP_FE(smfi_setflags, NULL)
 	PHP_FE(smfi_settimeout, NULL)
 	PHP_FE(smfi_getsymval, NULL)
diff --git a/sapi/nsapi/nsapi.c b/sapi/nsapi/nsapi.c
index 30da49a2e08..5c8a87d2141 100644
--- a/sapi/nsapi/nsapi.c
+++ b/sapi/nsapi/nsapi.c
@@ -172,7 +172,7 @@ ZEND_DECLARE_MODULE_GLOBALS(nsapi)
  *
  * 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 */