--- embedaddon/php/Zend/zend_execute.h	2012/02/21 23:47:52	1.1.1.1
+++ embedaddon/php/Zend/zend_execute.h	2012/05/29 12:34:35	1.1.1.2
@@ -17,7 +17,7 @@
    +----------------------------------------------------------------------+
 */
 
-/* $Id: zend_execute.h,v 1.1.1.1 2012/02/21 23:47:52 misho Exp $ */
+/* $Id: zend_execute.h,v 1.1.1.2 2012/05/29 12:34:35 misho Exp $ */
 
 #ifndef ZEND_EXECUTE_H
 #define ZEND_EXECUTE_H
@@ -35,16 +35,13 @@ typedef union _temp_variable {
 		zend_bool fcall_returned_reference;
 	} var;
 	struct {
-		zval **ptr_ptr;
-		zval *ptr;
-		zend_bool fcall_returned_reference;
+		zval **ptr_ptr; /* shared with var.ptr_ptr */
 		zval *str;
 		zend_uint offset;
 	} str_offset;
 	struct {
-		zval **ptr_ptr;
-		zval *ptr;
-		zend_bool fcall_returned_reference;
+		zval **ptr_ptr; /* shared with var.ptr_ptr */
+		zval *ptr;      /* shared with var.ptr */
 		HashPointer fe_pos;
 	} fe;
 	zend_class_entry *class_entry;
@@ -62,7 +59,7 @@ ZEND_API void execute(zend_op_array *op_array TSRMLS_D
 ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, int return_value_used TSRMLS_DC);
 ZEND_API int zend_is_true(zval *op);
 #define safe_free_zval_ptr(p) safe_free_zval_ptr_rel(p ZEND_FILE_LINE_CC ZEND_FILE_LINE_EMPTY_CC)
-static inline void safe_free_zval_ptr_rel(zval *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
+static zend_always_inline void safe_free_zval_ptr_rel(zval *p ZEND_FILE_LINE_DC ZEND_FILE_LINE_ORIG_DC)
 {
 	TSRMLS_FETCH();
 
@@ -71,14 +68,38 @@ static inline void safe_free_zval_ptr_rel(zval *p ZEND
 	}
 }
 ZEND_API int zend_lookup_class(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC);
-ZEND_API int zend_lookup_class_ex(const char *name, int name_length, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
+ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
 ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
 ZEND_API int zend_eval_stringl_ex(char *str, int str_len, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
 
-static inline int i_zend_is_true(zval *op)
+ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, const char **class_name, zend_class_entry **pce TSRMLS_DC);
+ZEND_API int zend_verify_arg_error(int error_type, const zend_function *zf, zend_uint arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC);
+
+static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC)
 {
+	if (!Z_DELREF_P(zval_ptr)) {
+		TSRMLS_FETCH();
+
+		if (zval_ptr != &EG(uninitialized_zval)) {
+			GC_REMOVE_ZVAL_FROM_BUFFER(zval_ptr);
+			zval_dtor(zval_ptr);
+			efree_rel(zval_ptr);
+		}
+	} else {
+		TSRMLS_FETCH();
+
+		if (Z_REFCOUNT_P(zval_ptr) == 1) {
+			Z_UNSET_ISREF_P(zval_ptr);
+		}
+
+		GC_ZVAL_CHECK_POSSIBLE_ROOT(zval_ptr);
+	}
+}
+
+static zend_always_inline int i_zend_is_true(zval *op)
+{
 	int result;
 
 	switch (Z_TYPE_P(op)) {
@@ -140,7 +161,7 @@ ZEND_API int zval_update_constant_no_inline_change(zva
 ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *scope TSRMLS_DC);
 
 /* dedicated Zend executor functions - do not use! */
-#define ZEND_VM_STACK_PAGE_SIZE ((64 * 1024) - 64)
+#define ZEND_VM_STACK_PAGE_SIZE ((16 * 1024) - 16)
 
 struct _zend_vm_stack {
 	void **top;
@@ -159,7 +180,7 @@ struct _zend_vm_stack {
 		}															\
 	} while (0)
 
-static inline zend_vm_stack zend_vm_stack_new_page(int count) {
+static zend_always_inline zend_vm_stack zend_vm_stack_new_page(int count) {
 	zend_vm_stack page = (zend_vm_stack)emalloc(ZEND_MM_ALIGNED_SIZE(sizeof(*page)) + sizeof(void*) * count);
 
 	page->top = ZEND_VM_STACK_ELEMETS(page);
@@ -168,12 +189,12 @@ static inline zend_vm_stack zend_vm_stack_new_page(int
 	return page;
 }
 
-static inline void zend_vm_stack_init(TSRMLS_D)
+static zend_always_inline void zend_vm_stack_init(TSRMLS_D)
 {
 	EG(argument_stack) = zend_vm_stack_new_page(ZEND_VM_STACK_PAGE_SIZE);
 }
 
-static inline void zend_vm_stack_destroy(TSRMLS_D)
+static zend_always_inline void zend_vm_stack_destroy(TSRMLS_D)
 {
 	zend_vm_stack stack = EG(argument_stack);
 
@@ -184,30 +205,30 @@ static inline void zend_vm_stack_destroy(TSRMLS_D)
 	}
 }
 
-static inline void zend_vm_stack_extend(int count TSRMLS_DC)
+static zend_always_inline void zend_vm_stack_extend(int count TSRMLS_DC)
 {
 	zend_vm_stack p = zend_vm_stack_new_page(count >= ZEND_VM_STACK_PAGE_SIZE ? count : ZEND_VM_STACK_PAGE_SIZE);
 	p->prev = EG(argument_stack);
 	EG(argument_stack) = p;
 }
 
-static inline void **zend_vm_stack_top(TSRMLS_D)
+static zend_always_inline void **zend_vm_stack_top(TSRMLS_D)
 {
 	return EG(argument_stack)->top;
 }
 
-static inline void zend_vm_stack_push(void *ptr TSRMLS_DC)
+static zend_always_inline void zend_vm_stack_push(void *ptr TSRMLS_DC)
 {
 	ZEND_VM_STACK_GROW_IF_NEEDED(1);
 	*(EG(argument_stack)->top++) = ptr;
 }
 
-static inline void zend_vm_stack_push_nocheck(void *ptr TSRMLS_DC)
+static zend_always_inline void zend_vm_stack_push_nocheck(void *ptr TSRMLS_DC)
 {
 	*(EG(argument_stack)->top++) = ptr;
 }
 
-static inline void *zend_vm_stack_pop(TSRMLS_D)
+static zend_always_inline void *zend_vm_stack_pop(TSRMLS_D)
 {
 	void *el = *(--EG(argument_stack)->top);
 
@@ -219,7 +240,7 @@ static inline void *zend_vm_stack_pop(TSRMLS_D)
 	return el;
 }
 
-static inline void *zend_vm_stack_alloc(size_t size TSRMLS_DC)
+static zend_always_inline void *zend_vm_stack_alloc(size_t size TSRMLS_DC)
 {
 	void *ret;
 
@@ -248,7 +269,7 @@ static inline void *zend_vm_stack_alloc(size_t size TS
 	return ret;
 }
 
-static inline void zend_vm_stack_free_int(void *ptr TSRMLS_DC)
+static zend_always_inline void zend_vm_stack_free_int(void *ptr TSRMLS_DC)
 {	
 	if (UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (void**)ptr)) {
 		zend_vm_stack p = EG(argument_stack);
@@ -260,7 +281,7 @@ static inline void zend_vm_stack_free_int(void *ptr TS
 	}
 }
 
-static inline void zend_vm_stack_free(void *ptr TSRMLS_DC)
+static zend_always_inline void zend_vm_stack_free(void *ptr TSRMLS_DC)
 {	
 	if (UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (void**)ptr)) {
 		zend_vm_stack p = EG(argument_stack);
@@ -278,7 +299,7 @@ static inline void zend_vm_stack_free(void *ptr TSRMLS
 	}
 }
 
-static inline void** zend_vm_stack_push_args(int count TSRMLS_DC)
+static zend_always_inline void** zend_vm_stack_push_args(int count TSRMLS_DC)
 {
 
 	if (UNEXPECTED(EG(argument_stack)->top - ZEND_VM_STACK_ELEMETS(EG(argument_stack)) < count)  || 
@@ -307,7 +328,7 @@ static inline void** zend_vm_stack_push_args(int count
 	return EG(argument_stack)->top++;
 }
 
-static inline void zend_vm_stack_clear_multiple(TSRMLS_D)
+static zend_always_inline void zend_vm_stack_clear_multiple(TSRMLS_D)
 {
 	void **p = EG(argument_stack)->top - 1;
 	int delete_count = (int)(zend_uintptr_t) *p;
@@ -315,12 +336,12 @@ static inline void zend_vm_stack_clear_multiple(TSRMLS
 	while (--delete_count>=0) {
 		zval *q = *(zval **)(--p);
 		*p = NULL;
-		zval_ptr_dtor(&q);
+		i_zval_ptr_dtor(q ZEND_FILE_LINE_CC);
 	}
 	zend_vm_stack_free_int(p TSRMLS_CC);
 }
 
-static inline zval** zend_vm_stack_get_arg(int requested_arg TSRMLS_DC)
+static zend_always_inline zval** zend_vm_stack_get_arg(int requested_arg TSRMLS_DC)
 {
 	void **p = EG(current_execute_data)->prev_execute_data->function_state.arguments;
 	int arg_count = (int)(zend_uintptr_t) *p;
@@ -331,7 +352,7 @@ static inline zval** zend_vm_stack_get_arg(int request
 	return (zval**)p - arg_count + requested_arg - 1;
 }
 
-static inline void zend_arg_types_stack_2_pop(zend_ptr_stack *stack, zval **object, zend_function **fbc)
+static zend_always_inline void zend_arg_types_stack_2_pop(zend_ptr_stack *stack, zval **object, zend_function **fbc)
 {
 	void *a, *b;
 
@@ -341,7 +362,7 @@ static inline void zend_arg_types_stack_2_pop(zend_ptr
 	*fbc = (zend_function *) b;
 }
 
-static inline void zend_arg_types_stack_3_pop(zend_ptr_stack *stack, zend_class_entry **called_scope, zval **object, zend_function **fbc)
+static zend_always_inline void zend_arg_types_stack_3_pop(zend_ptr_stack *stack, zend_class_entry **called_scope, zval **object, zend_function **fbc)
 {
 	void *a, *b, *c;
 
@@ -356,9 +377,9 @@ void execute_new_code(TSRMLS_D);
 
 
 /* services */
-ZEND_API char *get_active_class_name(char **space TSRMLS_DC);
-ZEND_API char *get_active_function_name(TSRMLS_D);
-ZEND_API char *zend_get_executed_filename(TSRMLS_D);
+ZEND_API const char *get_active_class_name(const char **space TSRMLS_DC);
+ZEND_API const char *get_active_function_name(TSRMLS_D);
+ZEND_API const char *zend_get_executed_filename(TSRMLS_D);
 ZEND_API uint zend_get_executed_lineno(TSRMLS_D);
 ZEND_API zend_bool zend_is_executing(TSRMLS_D);
 
@@ -366,6 +387,7 @@ ZEND_API void zend_set_timeout(long seconds, int reset
 ZEND_API void zend_unset_timeout(TSRMLS_D);
 ZEND_API void zend_timeout(int dummy);
 ZEND_API zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len, int fetch_type TSRMLS_DC);
+ZEND_API zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC);
 void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC);
 
 #ifdef ZEND_WIN32
@@ -404,10 +426,27 @@ typedef struct _zend_free_op {
 /*	int   is_var; */
 } zend_free_op;
 
-ZEND_API zval *zend_get_zval_ptr(znode *node, const temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC);
-ZEND_API zval **zend_get_zval_ptr_ptr(const znode *node, const temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC);
+ZEND_API zval *zend_get_zval_ptr(int op_type, const znode_op *node, const temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC);
+ZEND_API zval **zend_get_zval_ptr_ptr(int op_type, const znode_op *node, const temp_variable *Ts, zend_free_op *should_free, int type TSRMLS_DC);
 
 ZEND_API int zend_do_fcall(ZEND_OPCODE_HANDLER_ARGS);
+
+#define CACHED_PTR(num) \
+	EG(active_op_array)->run_time_cache[(num)]
+
+#define CACHE_PTR(num, ptr) do { \
+		EG(active_op_array)->run_time_cache[(num)] = (ptr); \
+	} while (0)
+
+#define CACHED_POLYMORPHIC_PTR(num, ce) \
+	((EG(active_op_array)->run_time_cache[(num)] == (ce)) ? \
+		EG(active_op_array)->run_time_cache[(num) + 1] : \
+		NULL)
+
+#define CACHE_POLYMORPHIC_PTR(num, ce, ptr) do { \
+		EG(active_op_array)->run_time_cache[(num)] = (ce); \
+		EG(active_op_array)->run_time_cache[(num) + 1] = (ptr); \
+	} while (0)
 
 END_EXTERN_C()