- Roll back VM commit

Author: Andi Gutmans

Zend/ChangeLog

@@ -1,30 +1,3 @@
-2004-09-08  Andi Gutmans  <andi@zend.com>
-
-    * zend_builtin_functions.c:
-      - Fix bug #28054 by preventing printing out bogus information in backtrace
-        when in error handler (still doesn't know all information but at least
-        it's not bogus)
-
-    * zend_compile.h
-      zend_exceptions.c
-      zend_execute.c
-      zend_execute.h
-      zend_execute_API.c
-      zend_opcode.c
-      zend_vm.h
-      zend_vm_handlers.h
-      zend_vm_spec.h:
-      - Some architectural changes:
-       a) We specialize opcodes according to op_type fields. Each opcode has to
-          be marked with which op_type's it uses.
-       b) We support different execution methods. Function handlers, switch()
-          and goto dispatching. goto seems to be the fastest but it really
-          depends on the compiler and how well it optimizes. I suggest playing
-          around with optimization flags.
-      
-      - Warning: Things might break so keep us posted on how things are going.
-        (Dmitry, Andi)
-
 2004-09-06  Marcus Boerger  <marcus.boerger@post.rwth-aachen.de>
 
     * zend_objects.c:

Zend/zend.c

@@ -84,6 +84,7 @@ ZEND_INI_END()
 ZEND_API int compiler_globals_id;
 ZEND_API int executor_globals_id;
 ZEND_API int alloc_globals_id;
+zend_class_entry global_main_class;
 HashTable *global_function_table;
 HashTable *global_class_table;
 HashTable *global_constants_table;

Zend/zend_API.c

@@ -316,13 +316,12 @@ static char *zend_parse_arg_impl(zval **arg, va_list *va, char **spec TSRMLS_DC)
 						*pl = Z_STRLEN_PP(arg);
 						break;
 					case IS_OBJECT: {
-						if (Z_OBJ_HANDLER_PP(arg, cast_object)) {
+						if (Z_OBJ_HANDLER_PP(arg, cast_object)
+							&& Z_OBJ_HANDLER_PP(arg, cast_object)(*arg, *arg, IS_STRING, 0 TSRMLS_CC) == SUCCESS) {
 							SEPARATE_ZVAL_IF_NOT_REF(arg);
-							if (Z_OBJ_HANDLER_PP(arg, cast_object)(*arg, *arg, IS_STRING, 0 TSRMLS_CC) == SUCCESS) {
-								*pl = Z_STRLEN_PP(arg);
-								*p = Z_STRVAL_PP(arg);
-								break;
-							}
+							*pl = Z_STRLEN_PP(arg);
+							*p = Z_STRVAL_PP(arg);
+							break;
 						}
 					}
 
@@ -1218,29 +1217,6 @@ ZEND_API int zend_startup_module(zend_module_entry *module)
 	return zend_register_module_ex(module TSRMLS_CC);
 }
 
-ZEND_API void zend_check_magic_method_implementation(zend_class_entry *ce, zend_function *fptr, int error_type TSRMLS_DC)
-{
-	char lcname[16];
-	int name_len;
-
-	/* we don't care if the function name is longer, in fact lowercasing only 
-	 * the beginning of the name speeds up the check process */
-	name_len = strlen(fptr->common.function_name);
-	zend_str_tolower_copy(lcname, fptr->common.function_name, MIN(name_len, sizeof(lcname)-1));
-	lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
-
-	if (name_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)) && fptr->common.num_args != 0) {
-		zend_error(error_type, "Destuctor %s::%s() cannot take arguments", ce->name, ZEND_DESTRUCTOR_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_CLONE_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)) && fptr->common.num_args != 0) {
-		zend_error(error_type, "Method %s::%s() cannot accept any arguments", ce->name, ZEND_CLONE_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_GET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)) && fptr->common.num_args != 1) {
-		zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name, ZEND_GET_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_SET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)) && fptr->common.num_args != 2) {
-		zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name, ZEND_SET_FUNC_NAME);
-	} else if (name_len == sizeof(ZEND_CALL_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)) && fptr->common.num_args != 2) {
-		zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name, ZEND_CALL_FUNC_NAME);
-	}
-}
 
 /* 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)
@@ -1251,11 +1227,9 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 	int count=0, unload=0;
 	HashTable *target_function_table = function_table;
 	int error_type;
-	zend_function *ctor = NULL, *dtor = NULL, *clone = NULL, *__get = NULL, *__set = NULL, *__call = NULL;
+	zend_function *ctor = NULL, *dtor = NULL, *clone = NULL;
 	char *lowercase_name;
 	int fname_len;
-	char *lc_class_name;
-	int class_name_len;
 
 	if (type==MODULE_PERSISTENT) {
 		error_type = E_CORE_WARNING;
@@ -1267,11 +1241,6 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 		target_function_table = CG(function_table);
 	}
 	internal_function->type = ZEND_INTERNAL_FUNCTION;
-	
-	if (scope) {
-		class_name_len = strlen(scope->name);
-		lc_class_name = zend_str_tolower_dup(scope->name, class_name_len);
-	}
 
 	while (ptr->fname) {
 		internal_function->handler = ptr->handler;
@@ -1341,38 +1310,25 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 			 * If it's an old-style constructor, store it only if we don't have
 			 * a constructor already.
 			 */
-			if ((fname_len == class_name_len) && !memcmp(lowercase_name, lc_class_name, class_name_len+1) && !ctor) {
+			if (!strcmp(ptr->fname, scope->name) && !ctor) {
 				ctor = reg_function;
-			} else if ((fname_len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME))) {
+			} else if (!strcmp(ptr->fname, ZEND_CONSTRUCTOR_FUNC_NAME)) {
 				ctor = reg_function;
-			} else if ((fname_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME))) {
+			} else if (!strcmp(ptr->fname, ZEND_DESTRUCTOR_FUNC_NAME)) {
 				dtor = reg_function;
 				if (internal_function->num_args) {
 					zend_error(error_type, "Destructor %s::%s() cannot take arguments", scope->name, ptr->fname);
 				}
-			} else if ((fname_len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME))) {
+
+			} else if (!strcmp(ptr->fname, ZEND_CLONE_FUNC_NAME)) {
 				clone = reg_function;
-			} else if ((fname_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME))) {
-				__call = reg_function;
-			} else if ((fname_len == sizeof(ZEND_GET_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME))) {
-				__get = reg_function;
-			} else if ((fname_len == sizeof(ZEND_SET_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME))) {
-				__set = reg_function;
-			} else {
-				reg_function = NULL;
-			}
-			if (reg_function) {
-				zend_check_magic_method_implementation(scope, reg_function, error_type TSRMLS_CC);
 			}
 		}
 		ptr++;
 		count++;
 		free_alloca(lowercase_name);
 	}
 	if (unload) { /* before unloading, display all remaining bad function in the module */
-		if (scope) {
-			efree(lc_class_name);
-		}
 		while (ptr->fname) {
 			if (zend_hash_exists(target_function_table, ptr->fname, strlen(ptr->fname)+1)) {
 				zend_error(error_type, "Function registration failed - duplicate name - %s", ptr->fname);
@@ -1386,49 +1342,27 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 		scope->constructor = ctor;
 		scope->destructor = dtor;
 		scope->clone = clone;
-		scope->__call = __call;
-		scope->__get = __get;
-		scope->__set = __set;
 		if (ctor) {
 			ctor->common.fn_flags |= ZEND_ACC_CTOR;
 			if (ctor->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Constructor %s::%s() cannot be static", scope->name, ctor->common.function_name);
+				zend_error(error_type, "Constructor %s::%s() cannot be static", ctor->common.scope->name, ctor->common.function_name);
 			}
 			ctor->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (dtor) {
 			dtor->common.fn_flags |= ZEND_ACC_DTOR;
 			if (dtor->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Destructor %s::%s() cannot be static", scope->name, dtor->common.function_name);
+				zend_error(error_type, "Destructor %s::%s() cannot be static", dtor->common.scope->name, dtor->common.function_name);
 			}
 			dtor->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (clone) {
 			clone->common.fn_flags |= ZEND_ACC_CLONE;
 			if (clone->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Constructor %s::%s() cannot be static", scope->name, clone->common.function_name);
+				zend_error(error_type, "Constructor %s::%s() cannot be static", clone->common.scope->name, clone->common.function_name);
 			}
 			clone->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
-		if (__call) {
-			if (__call->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __call->common.function_name);
-			}
-			__call->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
-		}
-		if (__get) {
-			if (__get->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __get->common.function_name);
-			}
-			__get->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
-		}
-		if (__set) {
-			if (__set->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __set->common.function_name);
-			}
-			__set->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
-		}
-		efree(lc_class_name);
 	}
 	return SUCCESS;
 }

Zend/zend_API.h

@@ -168,7 +168,6 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, zend_function_entr
 ZEND_API void zend_unregister_functions(zend_function_entry *functions, int count, HashTable *function_table TSRMLS_DC);
 ZEND_API int zend_register_module(zend_module_entry *module_entry);
 ZEND_API int zend_register_module_ex(zend_module_entry *module TSRMLS_DC);
-ZEND_API void zend_check_magic_method_implementation(zend_class_entry *ce, zend_function *fptr, int error_type TSRMLS_DC);
 
 ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry TSRMLS_DC);
 ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name TSRMLS_DC);

Zend/zend_builtin_functions.c

@@ -1621,7 +1621,7 @@ ZEND_FUNCTION(debug_print_backtrace)
 			zval_ptr_dtor(&arg_array);
 		}
 		zend_printf(") called at [%s:%d]\n", filename, lineno);
-		include_filename = function_name?NULL:filename;
+		include_filename = filename;
 		ptr = ptr->prev_execute_data;
 		++indent;
 	}
@@ -1766,7 +1766,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last TSRML
 
 		add_next_index_zval(return_value, stack_frame);
 
-		include_filename = function_name?NULL:filename; 
+		include_filename = filename; 
 
 		ptr = ptr->prev_execute_data;
 	}

Zend/zend_compile.c

@@ -1103,14 +1103,25 @@ void zend_do_end_function_declaration(znode *function_token TSRMLS_DC)
 
 	pass_two(CG(active_op_array) TSRMLS_CC);
 
+	/* we don't care if the function name is longer, in fact lowercasing only 
+	 * the beginning of the name speeds up the check process */
+	name_len = strlen(CG(active_op_array)->function_name);
+	zend_str_tolower_copy(lcname, CG(active_op_array)->function_name, MIN(name_len, sizeof(lcname)-1));
+	lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
+
 	if (CG(active_class_entry)) {
-		zend_check_magic_method_implementation(CG(active_class_entry), (zend_function*)CG(active_op_array), E_COMPILE_ERROR TSRMLS_CC);
+		if (name_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)) && CG(active_op_array)->num_args != 0) {
+			zend_error(E_COMPILE_ERROR, "Destuctor %s::%s() cannot take arguments", CG(active_class_entry)->name, ZEND_DESTRUCTOR_FUNC_NAME);
+		} else if (name_len == sizeof(ZEND_CLONE_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)) && CG(active_op_array)->num_args != 0) {
+			zend_error(E_COMPILE_ERROR, "Method %s::%s() cannot accept any arguments", CG(active_class_entry)->name, ZEND_CLONE_FUNC_NAME);
+		} else if (name_len == sizeof(ZEND_GET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)) && CG(active_op_array)->num_args != 1) {
+			zend_error(E_COMPILE_ERROR, "Method %s::%s() must take exactly 1 argument", CG(active_class_entry)->name, ZEND_GET_FUNC_NAME);
+		} else if (name_len == sizeof(ZEND_SET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)) && CG(active_op_array)->num_args != 2) {
+			zend_error(E_COMPILE_ERROR, "Method %s::%s() must take exactly 2 arguments", CG(active_class_entry)->name, ZEND_SET_FUNC_NAME);
+		} else if (name_len == sizeof(ZEND_CALL_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)) && CG(active_op_array)->num_args != 2) {
+			zend_error(E_COMPILE_ERROR, "Method %s::%s() must take exactly 2 arguments", CG(active_class_entry)->name, ZEND_CALL_FUNC_NAME);
+		}
 	} else {
-		/* we don't care if the function name is longer, in fact lowercasing only 
-		 * the beginning of the name speeds up the check process */
-		name_len = strlen(CG(active_op_array)->function_name);
-		zend_str_tolower_copy(lcname, CG(active_op_array)->function_name, MIN(name_len, sizeof(lcname)-1));
-		lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
 		if (name_len == sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)) && CG(active_op_array)->num_args != 1) {
 			zend_error(E_COMPILE_ERROR, "%s() must take exactly 1 argument", ZEND_AUTOLOAD_FUNC_NAME);
 		}		

Zend/zend_compile.h

@@ -72,7 +72,7 @@ typedef struct _zend_execute_data zend_execute_data;
 
 typedef int (*opcode_handler_t) (ZEND_OPCODE_HANDLER_ARGS);
 
-extern ZEND_API opcode_handler_t *zend_opcode_handlers;
+extern ZEND_API opcode_handler_t zend_opcode_handlers[512];
 
 struct _zend_op {
 	opcode_handler_t handler;

Zend/zend_exceptions.c

@@ -175,7 +175,7 @@ ZEND_METHOD(error_exception, __construct)
 	if (argc >= 4) {
 	    zend_update_property_string(default_exception_ce, object, "file", sizeof("file")-1, filename TSRMLS_CC);
     	if (argc < 5) {
-    	    lineno = 0; /* invalidate lineno */
+    	    lineno = 0; // invalidate lineno
     	}
     	zend_update_property_long(default_exception_ce, object, "line", sizeof("line")-1, lineno TSRMLS_CC);
 	}