Merge branch 'master' of https://git.php.net/push/php-src

* 'master' of https://git.php.net/push/php-src: (6215 commits)
  Extra comma
  Moved proxy object support in ASSIGN_ADD (and family) from VM to slow paths of corresponding operators
  Simplification
  zend_get_property_info_quick() cleanup and optimization
  initialize lineno before calling compile file file in phar
  Use ADDREF instead of DUP, it must be enough.
  Removed old irrelevant comment
  fixed compilation error
  Fix bug #68262: Broken reference across cloned objects
  export functions needed for phpdbg
  Fixed compilation
  Optimized property access handlers. Removed EG(std_property_info).
  Fixed bug #68199 (PDO::pgsqlGetNotify doesn't support NOTIFY payloads)
  Don't make difference between undefined and unaccessible properies when call __get() and family
  Don't make useless CSE
  array_pop/array_shift optimization
  check for zlib headers as well as lib for mysqlnd
  a realpath cache key can be int or float, catching this
  News entry for new curl constants
  News entry for new curl constants
  ...

1 files changed, 131 insertions, 173 deletions

diff --git a/Zend/zend_list.c b/Zend/zend_list.c
index e60deb1cd1..d8141f8664 100644
--- a/Zend/zend_list.c
+++ b/Zend/zend_list.c
@@ -2,7 +2,7 @@
    +----------------------------------------------------------------------+
    | Zend Engine                                                          |
    +----------------------------------------------------------------------+
-   | Copyright (c) 1998-2013 Zend Technologies Ltd. (http://www.zend.com) |
+   | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
    +----------------------------------------------------------------------+
    | This source file is subject to version 2.00 of the Zend license,     |
    | that is bundled with this package in the file LICENSE, and is        | 
@@ -31,88 +31,85 @@ ZEND_API int le_index_ptr;
 /* true global */
 static HashTable list_destructors;
 
-
-ZEND_API int zend_list_insert(void *ptr, int type TSRMLS_DC)
+ZEND_API zval *zend_list_insert(void *ptr, int type TSRMLS_DC)
 {
 	int index;
-	zend_rsrc_list_entry le;
-
-	le.ptr=ptr;
-	le.type=type;
-	le.refcount=1;
+	zval zv;
 
 	index = zend_hash_next_free_element(&EG(regular_list));
-
-	zend_hash_index_update(&EG(regular_list), index, (void *) &le, sizeof(zend_rsrc_list_entry), NULL);
-	return index;
+	if (index == 0) {
+		index = 1;
+	}
+	ZVAL_NEW_RES(&zv, index, ptr, type);
+	return zend_hash_index_add_new(&EG(regular_list), index, &zv);
 }
 
-ZEND_API int _zend_list_delete(int id TSRMLS_DC)
+ZEND_API int _zend_list_delete(zend_resource *res TSRMLS_DC)
 {
-	zend_rsrc_list_entry *le;
-	
-	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
-/*		printf("del(%d): %d->%d\n", id, le->refcount, le->refcount-1); */
-		if (--le->refcount<=0) {
-			return zend_hash_index_del(&EG(regular_list), id);
-		} else {
-			return SUCCESS;
-		}
+	if (--GC_REFCOUNT(res) <= 0) {
+		return zend_hash_index_del(&EG(regular_list), res->handle);
 	} else {
-		return FAILURE;
+		return SUCCESS;
 	}
 }
 
-
-ZEND_API void *_zend_list_find(int id, int *type TSRMLS_DC)
+ZEND_API int _zend_list_free(zend_resource *res TSRMLS_DC)
 {
-	zend_rsrc_list_entry *le;
-
-	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
-		*type = le->type;
-		return le->ptr;
+	if (GC_REFCOUNT(res) <= 0) {
+		return zend_hash_index_del(&EG(regular_list), res->handle);
 	} else {
-		*type = -1;
-		return NULL;
+		return SUCCESS;
 	}
 }
 
-ZEND_API int _zend_list_addref(int id TSRMLS_DC)
+static void zend_resource_dtor(zend_resource *res TSRMLS_DC)
 {
-	zend_rsrc_list_entry *le;
+	zend_rsrc_list_dtors_entry *ld;
 	
-	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
-/*		printf("add(%d): %d->%d\n", id, le->refcount, le->refcount+1); */
-		le->refcount++;
-		return SUCCESS;
+	ld = zend_hash_index_find_ptr(&list_destructors, res->type);
+	if (ld) {
+		if (ld->list_dtor_ex) {
+			ld->list_dtor_ex(res TSRMLS_CC);
+		}
 	} else {
-		return FAILURE;
+		zend_error(E_WARNING,"Unknown list entry type (%d)", res->type);
 	}
+	res->ptr = NULL;
+	res->type = -1;
 }
 
 
-ZEND_API int zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type TSRMLS_DC)
+ZEND_API int _zend_list_close(zend_resource *res TSRMLS_DC)
+{
+	if (GC_REFCOUNT(res) <= 0) {
+		return zend_list_delete(res);
+	} else if (res->type >= 0) {
+		zend_resource_dtor(res TSRMLS_CC);
+	}
+	return SUCCESS;
+}
+
+ZEND_API zend_resource* zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type TSRMLS_DC)
 {
-	int rsrc_id;
+	zval *zv;
 
-	rsrc_id = zend_list_insert(rsrc_pointer, rsrc_type TSRMLS_CC);
+	zv = zend_list_insert(rsrc_pointer, rsrc_type TSRMLS_CC);
 	
 	if (rsrc_result) {
-		rsrc_result->value.lval = rsrc_id;
-		rsrc_result->type = IS_RESOURCE;
+		ZVAL_COPY_VALUE(rsrc_result, zv);
+		return Z_RES_P(rsrc_result);
+	} else {
+		return Z_RES_P(zv);
 	}
-
-	return rsrc_id;
 }
 
-
-ZEND_API void *zend_fetch_resource(zval **passed_id TSRMLS_DC, int default_id, const char *resource_type_name, int *found_resource_type, int num_resource_types, ...)
+ZEND_API void *zend_fetch_resource(zval *passed_id TSRMLS_DC, int default_id, const char *resource_type_name, int *found_resource_type, int num_resource_types, ...)
 {
-	int id;
 	int actual_resource_type;
-	void *resource;
+//	void *resource;
 	va_list resource_types;
 	int i;
+	zend_resource *res;
 	const char *space;
 	const char *class_name;
 
@@ -123,26 +120,25 @@ ZEND_API void *zend_fetch_resource(zval **passed_id TSRMLS_DC, int default_id, c
 				zend_error(E_WARNING, "%s%s%s(): no %s resource supplied", class_name, space, get_active_function_name(TSRMLS_C), resource_type_name);
 			}
 			return NULL;
-		} else if ((*passed_id)->type != IS_RESOURCE) {
+		} else if (Z_TYPE_P(passed_id) != IS_RESOURCE) {
 			if (resource_type_name) {
 				class_name = get_active_class_name(&space TSRMLS_CC);
 				zend_error(E_WARNING, "%s%s%s(): supplied argument is not a valid %s resource", class_name, space, get_active_function_name(TSRMLS_C), resource_type_name);
 			}
 			return NULL;
 		}
-		id = (*passed_id)->value.lval;
 	} else {
-		id = default_id;
-	}
-
-	resource = zend_list_find(id, &actual_resource_type);
-	if (!resource) {
-		if (resource_type_name) {
-			class_name = get_active_class_name(&space TSRMLS_CC);
-			zend_error(E_WARNING, "%s%s%s(): %d is not a valid %s resource", class_name, space, get_active_function_name(TSRMLS_C), id, resource_type_name);
+		passed_id = zend_hash_index_find(&EG(regular_list), default_id);
+		if (!passed_id) {
+			if (resource_type_name) {
+				class_name = get_active_class_name(&space TSRMLS_CC);
+				zend_error(E_WARNING, "%s%s%s(): %d is not a valid %s resource", class_name, space, get_active_function_name(TSRMLS_C), default_id, resource_type_name);
+			}
+			return NULL;
 		}
-		return NULL;
 	}
+	res = Z_RES_P(passed_id);
+	actual_resource_type = res->type;
 
 	va_start(resource_types, num_resource_types);
 	for (i=0; i<num_resource_types; i++) {
@@ -151,7 +147,7 @@ ZEND_API void *zend_fetch_resource(zval **passed_id TSRMLS_DC, int default_id, c
 			if (found_resource_type) {
 				*found_resource_type = actual_resource_type;
 			}
-			return resource;
+			return res->ptr;
 		}
 	}
 	va_end(resource_types);
@@ -164,73 +160,66 @@ ZEND_API void *zend_fetch_resource(zval **passed_id TSRMLS_DC, int default_id, c
 	return NULL;
 }
 
+void list_entry_destructor(zval *zv)
+{
+	zend_resource *res = Z_RES_P(zv);
 
-void list_entry_destructor(void *ptr)
+	if (res->type >= 0) {
+		TSRMLS_FETCH();
+	
+		zend_resource_dtor(res TSRMLS_CC);
+	}
+	efree_size(res, sizeof(zend_resource));
+}
+
+void plist_entry_destructor(zval *zv)
 {
-	zend_rsrc_list_entry *le = (zend_rsrc_list_entry *) ptr;
-	zend_rsrc_list_dtors_entry *ld;
-	TSRMLS_FETCH();
+	zend_resource *res = Z_RES_P(zv);
+
+	if (res->type >= 0) {
+		zend_rsrc_list_dtors_entry *ld;
+		TSRMLS_FETCH();
 	
-	if (zend_hash_index_find(&list_destructors, le->type, (void **) &ld)==SUCCESS) {
-		switch (ld->type) {
-			case ZEND_RESOURCE_LIST_TYPE_STD:
-				if (ld->list_dtor) {
-					(ld->list_dtor)(le->ptr);
-				}
-				break;
-			case ZEND_RESOURCE_LIST_TYPE_EX:
-				if (ld->list_dtor_ex) {
-					ld->list_dtor_ex(le TSRMLS_CC);
-				}
-				break;
-			EMPTY_SWITCH_DEFAULT_CASE()
+		ld = zend_hash_index_find_ptr(&list_destructors, res->type);
+		if (ld) {
+			if (ld->plist_dtor_ex) {
+				ld->plist_dtor_ex(res TSRMLS_CC);
+			}
+		} else {
+			zend_error(E_WARNING,"Unknown list entry type (%d)", res->type);
 		}
-	} else {
-		zend_error(E_WARNING,"Unknown list entry type in request shutdown (%d)", le->type);
 	}
+	free(res);
+}
+
+int zend_init_rsrc_list(TSRMLS_D)
+{
+	zend_hash_init(&EG(regular_list), 8, NULL, list_entry_destructor, 0);
+	return SUCCESS;
 }
 
 
-void plist_entry_destructor(void *ptr)
+int zend_init_rsrc_plist(TSRMLS_D)
 {
-	zend_rsrc_list_entry *le = (zend_rsrc_list_entry *) ptr;
-	zend_rsrc_list_dtors_entry *ld;
-	TSRMLS_FETCH();
-
-	if (zend_hash_index_find(&list_destructors, le->type, (void **) &ld)==SUCCESS) {
-		switch (ld->type) {
-			case ZEND_RESOURCE_LIST_TYPE_STD:
-				if (ld->plist_dtor) {
-					(ld->plist_dtor)(le->ptr);
-				}
-				break;
-			case ZEND_RESOURCE_LIST_TYPE_EX:
-				if (ld->plist_dtor_ex) {
-					ld->plist_dtor_ex(le TSRMLS_CC);
-				}
-				break;
-				EMPTY_SWITCH_DEFAULT_CASE()
-		}
-	} else {
-		zend_error(E_WARNING,"Unknown persistent list entry type in module shutdown (%d)", le->type);
-	}
+	zend_hash_init_ex(&EG(persistent_list), 8, NULL, plist_entry_destructor, 1, 0);
+	return SUCCESS;
 }
 
 
-int zend_init_rsrc_list(TSRMLS_D)
+static int zend_close_rsrc(zval *zv TSRMLS_DC)
 {
-	if (zend_hash_init(&EG(regular_list), 0, NULL, list_entry_destructor, 0)==SUCCESS) {
-		EG(regular_list).nNextFreeElement=1;	/* we don't want resource id 0 */
-		return SUCCESS;
-	} else {
-		return FAILURE;
+	zend_resource *res = Z_PTR_P(zv);
+
+	if (res->type >= 0) {
+		zend_resource_dtor(res TSRMLS_CC);
 	}
+	return ZEND_HASH_APPLY_KEEP;
 }
 
 
-int zend_init_rsrc_plist(TSRMLS_D)
+void zend_close_rsrc_list(HashTable *ht TSRMLS_DC)
 {
-	return zend_hash_init_ex(&EG(persistent_list), 0, NULL, plist_entry_destructor, 1, 0);
+	zend_hash_reverse_apply(ht, zend_close_rsrc TSRMLS_CC);
 }
 
 
@@ -239,9 +228,10 @@ void zend_destroy_rsrc_list(HashTable *ht TSRMLS_DC)
 	zend_hash_graceful_reverse_destroy(ht);
 }
 
-static int clean_module_resource(zend_rsrc_list_entry *le, int *resource_id TSRMLS_DC)
+static int clean_module_resource(zval *zv, void *arg TSRMLS_DC)
 {
-	if (le->type == *resource_id) {
+	int resource_id = *(int *)arg;
+	if (Z_RES_TYPE_P(zv) == resource_id) {
 		return 1;
 	} else {
 		return 0;
@@ -249,10 +239,12 @@ static int clean_module_resource(zend_rsrc_list_entry *le, int *resource_id TSRM
 }
 
 
-static int zend_clean_module_rsrc_dtors_cb(zend_rsrc_list_dtors_entry *ld, int *module_number TSRMLS_DC)
+static int zend_clean_module_rsrc_dtors_cb(zval *zv, void *arg TSRMLS_DC)
 {
-	if (ld->module_number == *module_number) {
-		zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) clean_module_resource, (void *) &(ld->resource_id) TSRMLS_CC);
+	zend_rsrc_list_dtors_entry *ld = (zend_rsrc_list_dtors_entry *)Z_PTR_P(zv);	
+	int module_number = *(int *)arg;
+	if (ld->module_number == module_number) {
+		zend_hash_apply_with_argument(&EG(persistent_list), clean_module_resource, (void *) &(ld->resource_id) TSRMLS_CC);
 		return 1;
 	} else {
 		return 0;
@@ -262,83 +254,52 @@ static int zend_clean_module_rsrc_dtors_cb(zend_rsrc_list_dtors_entry *ld, int *
 
 void zend_clean_module_rsrc_dtors(int module_number TSRMLS_DC)
 {
-	zend_hash_apply_with_argument(&list_destructors, (apply_func_arg_t) zend_clean_module_rsrc_dtors_cb, (void *) &module_number TSRMLS_CC);
-}
-
-
-ZEND_API int zend_register_list_destructors(void (*ld)(void *), void (*pld)(void *), int module_number)
-{
-	zend_rsrc_list_dtors_entry lde;
-	
-#if 0
-	printf("Registering destructors %d for module %d\n", list_destructors.nNextFreeElement, module_number);
-#endif
-	
-	lde.list_dtor=(void (*)(void *)) ld;
-	lde.plist_dtor=(void (*)(void *)) pld;
-	lde.list_dtor_ex = lde.plist_dtor_ex = NULL;
-	lde.module_number = module_number;
-	lde.resource_id = list_destructors.nNextFreeElement;
-	lde.type = ZEND_RESOURCE_LIST_TYPE_STD;
-	lde.type_name = NULL;
-	
-	if (zend_hash_next_index_insert(&list_destructors, (void *) &lde, sizeof(zend_rsrc_list_dtors_entry), NULL)==FAILURE) {
-		return FAILURE;
-	}
-	return list_destructors.nNextFreeElement-1;
+	zend_hash_apply_with_argument(&list_destructors, zend_clean_module_rsrc_dtors_cb, (void *) &module_number TSRMLS_CC);
 }
 
 
 ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, const char *type_name, int module_number)
 {
-	zend_rsrc_list_dtors_entry lde;
+	zend_rsrc_list_dtors_entry *lde;
+	zval zv;
 	
-#if 0
-	printf("Registering destructors %d for module %d\n", list_destructors.nNextFreeElement, module_number);
-#endif
-
-	lde.list_dtor = NULL;
-	lde.plist_dtor = NULL;
-	lde.list_dtor_ex = ld;
-	lde.plist_dtor_ex = pld;
-	lde.module_number = module_number;
-	lde.resource_id = list_destructors.nNextFreeElement;
-	lde.type = ZEND_RESOURCE_LIST_TYPE_EX;
-	lde.type_name = type_name;
+	lde = malloc(sizeof(zend_rsrc_list_dtors_entry));	
+	lde->list_dtor_ex = ld;
+	lde->plist_dtor_ex = pld;
+	lde->module_number = module_number;
+	lde->resource_id = list_destructors.nNextFreeElement;
+	lde->type_name = type_name;
+	ZVAL_PTR(&zv, lde);
 	
-	if (zend_hash_next_index_insert(&list_destructors, (void *) &lde, sizeof(zend_rsrc_list_dtors_entry), NULL)==FAILURE) {
+	if (zend_hash_next_index_insert(&list_destructors, &zv) == NULL) {
 		return FAILURE;
 	}
 	return list_destructors.nNextFreeElement-1;
 }
 
-ZEND_API int zend_fetch_list_dtor_id(char *type_name)
+ZEND_API int zend_fetch_list_dtor_id(const char *type_name)
 {
 	zend_rsrc_list_dtors_entry *lde;
-	HashPosition pos;
 
-	zend_hash_internal_pointer_reset_ex(&list_destructors, &pos);
-	while (zend_hash_get_current_data_ex(&list_destructors, (void **)&lde, &pos) == SUCCESS) {
+	ZEND_HASH_FOREACH_PTR(&list_destructors, lde) {
 		if (lde->type_name && (strcmp(type_name, lde->type_name) == 0)) {
-#if 0
-			printf("Found resource id %d for resource type %s\n", (*lde).resource_id, type_name);
-#endif
 			return lde->resource_id;
 		}
-		zend_hash_move_forward_ex(&list_destructors, &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	return 0;
 }
 
-int zend_init_rsrc_list_dtors(void)
+static void list_destructors_dtor(zval *zv)
 {
-	int retval;
+	free(Z_PTR_P(zv));
+}
 
-	retval = zend_hash_init(&list_destructors, 50, NULL, NULL, 1);
+int zend_init_rsrc_list_dtors(void)
+{
+	zend_hash_init(&list_destructors, 64, NULL, list_destructors_dtor, 1);
 	list_destructors.nNextFreeElement=1;	/* we don't want resource type 0 */
-
-	return retval;
+	return SUCCESS;
 }
 
 
@@ -348,15 +309,12 @@ void zend_destroy_rsrc_list_dtors(void)
 }
 
 
-const char *zend_rsrc_list_get_rsrc_type(int resource TSRMLS_DC)
+const char *zend_rsrc_list_get_rsrc_type(zend_resource *res TSRMLS_DC)
 {
 	zend_rsrc_list_dtors_entry *lde;
-	int rsrc_type;
-
-	if (!zend_list_find(resource, &rsrc_type))
-		return NULL;
 
-	if (zend_hash_index_find(&list_destructors, rsrc_type, (void **) &lde)==SUCCESS) {
+	lde = zend_hash_index_find_ptr(&list_destructors, res->type);
+	if (lde) {
 		return lde->type_name;
 	} else {
 		return NULL;