PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
{
void *next;
zend_long i;
var_entries *var_hash = (*var_hashx)->first;
var_dtor_entries *var_dtor_hash = (*var_hashx)->first_dtor;
#if VAR_ENTRIES_DBG
fprintf(stderr, "var_destroy(%ld)\n", var_hash?var_hash->used_slots:-1L);
#endif
while (var_hash) {
next = var_hash->next;
efree_size(var_hash, sizeof(var_entries));
var_hash = next;
}
while (var_dtor_hash) {
for (i = 0; i < var_dtor_hash->used_slots; i++) {
#if VAR_ENTRIES_DBG
fprintf(stderr, "var_destroy dtor(%p, %ld)\n", var_dtor_hash->data[i], Z_REFCOUNT_P(var_dtor_hash->data[i]));
#endif
zval_ptr_dtor(&var_dtor_hash->data[i]);
}
next = var_dtor_hash->next;
efree_size(var_dtor_hash, sizeof(var_dtor_entries));
var_dtor_hash = next;
}
}
PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
{
void *next;
zend_long i;
var_entries *var_hash = (*var_hashx)->first;
var_dtor_entries *var_dtor_hash = (*var_hashx)->first_dtor;
zend_bool wakeup_failed = 0;
zval wakeup_name;
ZVAL_UNDEF(&wakeup_name);
#if VAR_ENTRIES_DBG
fprintf(stderr, "var_destroy(%ld)\n", var_hash?var_hash->used_slots:-1L);
#endif
while (var_hash) {
next = var_hash->next;
efree_size(var_hash, sizeof(var_entries));
var_hash = next;
}
while (var_dtor_hash) {
for (i = 0; i < var_dtor_hash->used_slots; i++) {
zval *zv = &var_dtor_hash->data[i];
#if VAR_ENTRIES_DBG
fprintf(stderr, "var_destroy dtor(%p, %ld)\n", var_dtor_hash->data[i], Z_REFCOUNT_P(var_dtor_hash->data[i]));
#endif
/* Perform delayed __wakeup calls */
if (Z_EXTRA_P(zv) == VAR_WAKEUP_FLAG) {
if (!wakeup_failed) {
zval retval;
if (Z_ISUNDEF(wakeup_name)) {
ZVAL_STRINGL(&wakeup_name, "__wakeup", sizeof("__wakeup") - 1);
}
BG(serialize_lock)++;
if (call_user_function_ex(CG(function_table), zv, &wakeup_name, &retval, 0, 0, 1, NULL) == FAILURE || Z_ISUNDEF(retval)) {
wakeup_failed = 1;
GC_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
}
BG(serialize_lock)--;
zval_ptr_dtor(&retval);
} else {
GC_FLAGS(Z_OBJ_P(zv)) |= IS_OBJ_DESTRUCTOR_CALLED;
}
}
i_zval_ptr_dtor(zv ZEND_FILE_LINE_CC);
}
next = var_dtor_hash->next;
efree_size(var_dtor_hash, sizeof(var_dtor_entries));
var_dtor_hash = next;
}
zval_ptr_dtor_nogc(&wakeup_name);
}
ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished_execution) /* {{{ */
{
if (Z_TYPE(generator->value) != IS_UNDEF) {
zval_ptr_dtor(&generator->value);
ZVAL_UNDEF(&generator->value);
}
if (Z_TYPE(generator->key) != IS_UNDEF) {
zval_ptr_dtor(&generator->key);
ZVAL_UNDEF(&generator->key);
}
if (generator->execute_data) {
zend_execute_data *execute_data = generator->execute_data;
zend_op_array *op_array = &execute_data->func->op_array;
if (!execute_data->symbol_table) {
zend_free_compiled_variables(execute_data);
} else {
zend_clean_and_cache_symbol_table(execute_data->symbol_table);
}
if (Z_OBJ(execute_data->This)) {
OBJ_RELEASE(Z_OBJ(execute_data->This));
}
/* A fatal error / die occurred during the generator execution. Trying to clean
* up the stack may not be safe in this case. */
if (CG(unclean_shutdown)) {
generator->execute_data = NULL;
return;
}
zend_vm_stack_free_extra_args(generator->execute_data);
/* Some cleanups are only necessary if the generator was closued
* before it could finish execution (reach a return statement). */
if (!finished_execution) {
zend_generator_cleanup_unfinished_execution(generator);
}
/* Free a clone of closure */
if (op_array->fn_flags & ZEND_ACC_CLOSURE) {
destroy_op_array(op_array);
efree_size(op_array, sizeof(zend_op_array));
}
efree(generator->stack);
generator->execute_data = NULL;
}
}
static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref)
{
i_zval_ptr_dtor(&ref->val ZEND_FILE_LINE_CC);
efree_size(ref, sizeof(zend_reference));
}
/**
* Do an internal require to a plain php file taking care of the value returned by the file
*/
int zephir_require_ret(zval *return_value_ptr, const char *require_path)
{
zend_file_handle file_handle;
int ret;
zend_op_array *new_op_array;
zval dummy, local_retval;
ZVAL_UNDEF(&local_retval);
#ifndef ZEPHIR_RELEASE
if (return_value_ptr != NULL && Z_TYPE_P(return_value_ptr) > IS_NULL) {
fprintf(stderr, "%s: *return_value_ptr is expected to be NULL", __func__);
zephir_print_backtrace();
abort();
}
#endif
/* if (!memcmp(require_path, "", 0)) {
@TODO, throw an exception here
return FAILURE;
} */
file_handle.filename = require_path;
file_handle.free_filename = 0;
file_handle.type = ZEND_HANDLE_FILENAME;
file_handle.opened_path = NULL;
file_handle.handle.fp = NULL;
new_op_array = zend_compile_file(&file_handle, ZEND_REQUIRE);
if (new_op_array) {
if (file_handle.handle.stream.handle) {
ZVAL_NULL(&dummy);
if (!file_handle.opened_path) {
file_handle.opened_path = zend_string_init(require_path, strlen(require_path), 0);
}
zend_hash_add(&EG(included_files), file_handle.opened_path, &dummy);
zend_destroy_file_handle(&file_handle);
}
new_op_array->scope = EG(scope);
zend_execute(new_op_array, &local_retval);
if (return_value_ptr) {
zval_ptr_dtor(return_value_ptr);
ZVAL_COPY_VALUE(return_value_ptr, &local_retval);
} else {
zval_ptr_dtor(&local_retval);
}
destroy_op_array(new_op_array);
efree_size(new_op_array, sizeof(zend_op_array));
if (EG(exception)) {
ret = FAILURE;
} else {
ret = SUCCESS;
}
return ret;
} else {
zend_destroy_file_handle(&file_handle);
}
return FAILURE;
}
static void ZEND_FASTCALL zend_reference_destroy(zend_reference *ref)
{
ZEND_ASSERT(!ZEND_REF_HAS_TYPE_SOURCES(ref));
i_zval_ptr_dtor(&ref->val);
efree_size(ref, sizeof(zend_reference));
}
