/** {{{ public ZeActiveString::update($oldCondition, $newCondition) */ PHP_METHOD(ze_activestring, update) { zval * self = NULL; zval * actives = NULL; char * old_cond = NULL; int old_cond_len = 0; char * new_cond = NULL; int new_cond_len = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss" , &old_cond, &old_cond_len , &new_cond, &new_cond_len ) == FAILURE) { WRONG_PARAM_COUNT; } self = getThis(); actives = zend_read_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), 0 TSRMLS_CC); zend_hash_del(Z_ARRVAL_P(actives), old_cond, old_cond_len + 1); add_assoc_bool(actives, new_cond, 1); zend_update_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), actives TSRMLS_CC); RETURN_ZVAL(self, 1, 0); }
/* {{{ MongoCursor->explain */ PHP_METHOD(MongoCursor, explain) { int temp_limit; zval *explain, *yes, *temp = 0; mongo_cursor *cursor = (mongo_cursor*)zend_object_store_get_object(getThis() TSRMLS_CC); MONGO_CHECK_INITIALIZED(cursor->link, MongoCursor); MONGO_METHOD(MongoCursor, reset, return_value, getThis()); // make explain use a hard limit temp_limit = cursor->limit; if (cursor->limit > 0) { cursor->limit *= -1; } MAKE_STD_ZVAL(explain); ZVAL_STRING(explain, "$explain", 1); MAKE_STD_ZVAL(yes); ZVAL_TRUE(yes); MONGO_METHOD2(MongoCursor, addOption, return_value, getThis(), explain, yes); zval_ptr_dtor(&explain); zval_ptr_dtor(&yes); MONGO_METHOD(MongoCursor, getNext, return_value, getThis()); // reset cursor to original state cursor->limit = temp_limit; zend_hash_del(HASH_P(cursor->query), "$explain", strlen("$explain")+1); MAKE_STD_ZVAL(temp); ZVAL_NULL(temp); MONGO_METHOD(MongoCursor, reset, temp, getThis()); zval_ptr_dtor(&temp); }
/** * Unsets zval index from array */ int phalcon_array_unset(zval *arr, zval *index){ zval *copy; if (Z_TYPE_P(arr) != IS_ARRAY) { return 0; } if (Z_TYPE_P(index) == IS_NULL) { ALLOC_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_string(copy); index = copy; } else { if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) { ALLOC_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_long(copy); index = copy; } } if (Z_TYPE_P(index) == IS_STRING) { return zend_hash_del(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1); } else { return zend_hash_index_del(Z_ARRVAL_P(arr), Z_LVAL_P(index)); } return 0; }
inline int sw_zend_hash_del(HashTable *ht, char *k, int len) { zval key; ZVAL_STRING(&key, k); return zend_hash_del(ht, Z_STR(key)); }
/** * @brief Unsets @a index from array @a arr * @param[in,out] arr Array * @param index Index * @param flags Flags (@c PH_SEPARATE: separate array if its reference count is greater than 1; @c arr will contain the separated array) * @return Whether the operation succeeded * @retval @c FAILURE Failure, @a arr is not an array or @a index is of not supported type * @retval @c SUCCESS Success * @note @c index will be handled as follows: @c NULL is treated as an empty string, @c double values are cast to @c integer, @c bool or @c resource are treated as @c integer * @throw @c E_WARNING if @a offset is not a scalar */ int ZEPHIR_FASTCALL zephir_array_unset(zval **arr, zval *index, int flags) { HashTable *ht; if (Z_TYPE_PP(arr) != IS_ARRAY) { return FAILURE; } if ((flags & PH_SEPARATE) == PH_SEPARATE) { SEPARATE_ZVAL_IF_NOT_REF(arr); } ht = Z_ARRVAL_PP(arr); switch (Z_TYPE_P(index)) { case IS_NULL: return (zend_hash_del(ht, "", 1) == SUCCESS); case IS_DOUBLE: return (zend_hash_index_del(ht, (ulong)Z_DVAL_P(index)) == SUCCESS); case IS_LONG: case IS_BOOL: case IS_RESOURCE: return (zend_hash_index_del(ht, Z_LVAL_P(index)) == SUCCESS); case IS_STRING: return (zend_symtable_del(ht, Z_STRVAL_P(index), Z_STRLEN_P(index)+1) == SUCCESS); default: zend_error(E_WARNING, "Illegal offset type"); return 0; } }
PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver) { if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) { return; } zend_hash_del(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len); }
static int php_pdo_connect_pool_close(cpClient *cli) { char str[100] = {0}; CON_FORMART_KEY(str, cli->port); if (zend_hash_del(&EG(persistent_list), str, strlen(str)) == FAILURE) {//很奇怪 用不了宏定义 zend_error(E_WARNING, "del hash error!"); return FAILURE; } return SUCCESS; }
ZEND_API int zend_ts_hash_del(TsHashTable *ht, zend_string *key) { int retval; begin_write(ht); retval = zend_hash_del(TS_HASH(ht), key); end_write(ht); return retval; }
PHP_COUCHBASE_LOCAL void pcbc_ht_del(zval *assoc, const char *key, unsigned int key_len) { pcbc_ht_key hk = { NULL }; ISARRAY_SANITY(assoc); pcbc_ht_key_create(key, key_len, &hk); zend_hash_del(Z_ARRVAL_P(assoc), hk.key, hk.key_len + 1); pcbc_ht_key_cleanup(&hk); }
/** {{{ int yaf_response_clear_header(yaf_response_t *response, char *name, uint name_len TSRMLS_DC) */ int yaf_response_clear_header(yaf_response_t *response, char *name, uint name_len TSRMLS_DC) { zval *zheader; zheader = zend_read_property(yaf_response_ce, response, ZEND_STRL(YAF_RESPONSE_PROPERTY_NAME_HEADER), 1 TSRMLS_CC); if (name_len) { zend_hash_del(Z_ARRVAL_P(zheader), name, name_len + 1); } else { zend_hash_clean(Z_ARRVAL_P(zheader)); } return 1; }
/* {{{ uninstall_class */ static int uninstall_class(apc_class_t cl TSRMLS_DC) { int status; status = zend_hash_del(EG(class_table), cl.name, cl.name_len+1); if (status == FAILURE) { apc_error("Cannot delete class %s" TSRMLS_CC, cl.name); } return status; }
void php_mongo_io_stream_forget(mongo_con_manager *manager, mongo_connection *con) { zend_rsrc_list_entry *le; TSRMLS_FETCH(); /* When we fork we need to unregister the parents hash so we don't accidentally destroy it */ if (zend_hash_find(&EG(persistent_list), con->hash, strlen(con->hash) + 1, (void*) &le) == SUCCESS) { ((php_stream *)con->socket)->in_free = 1; zend_hash_del(&EG(persistent_list), con->hash, strlen(con->hash) + 1); ((php_stream *)con->socket)->in_free = 0; } }
/** * @brief Unsets string @a index from array @a arr * @param[in,out] arr Array * @param index Index * @param index_length strlen(index)+1 * @param flags Flags (@c PH_SEPARATE: separate array if its reference count is greater than 1; @c arr will contain the separated array) * @return Whether the operation succeeded * @retval @c FAILURE Failure or @a arr is not an array * @retval @c SUCCESS Success */ int ZEPHIR_FASTCALL zephir_array_unset_string(zval **arr, const char *index, uint index_length, int flags) { if (Z_TYPE_PP(arr) != IS_ARRAY) { return 0; } if ((flags & PH_SEPARATE) == PH_SEPARATE) { SEPARATE_ZVAL_IF_NOT_REF(arr); } return zend_hash_del(Z_ARRVAL_PP(arr), index, index_length); }
static void phpdbg_remove_watch_collision(phpdbg_watchpoint_t *watch) { phpdbg_watch_collision *cur; if ((cur = zend_hash_index_find_ptr(&PHPDBG_G(watch_collisions), (zend_ulong) Z_COUNTED_P(watch->addr.zv)))) { if (cur->refs && !--cur->refs) { phpdbg_delete_watchpoints_recursive(watch); } zend_hash_del(&cur->watches, watch->str); zend_hash_del(&cur->implicit_watches, watch->str); if (zend_hash_num_elements(&cur->watches) > 0) { cur->watch = Z_PTR_P(zend_hash_get_current_data_ex(&cur->watches, NULL)); } else if (zend_hash_num_elements(&cur->implicit_watches) > 0) { cur->watch = Z_PTR_P(zend_hash_get_current_data_ex(&cur->implicit_watches, NULL)); } else { phpdbg_deactivate_watchpoint(cur->watch); phpdbg_remove_watchpoint(cur->watch); zend_hash_index_del(&PHPDBG_G(watch_collisions), (zend_ulong) Z_COUNTED_P(watch->addr.zv)); } } }
void uopz_unset_mock(zend_string *clazz) { /* {{{ */ zend_string *key = zend_string_tolower(clazz); if (!zend_hash_exists(&UOPZ(mocks), key)) { uopz_exception( "the class provided (%s) has no mock set", ZSTR_VAL(clazz)); zend_string_release(key); return; } zend_hash_del(&UOPZ(mocks), key); zend_string_release(key); } /* }}} */
/** * Unsets zval index from array */ int PHALCON_FASTCALL phalcon_array_unset(zval **arr, zval *index, int flags) { zval *copy; int exists, copied = 0; if (Z_TYPE_PP(arr) != IS_ARRAY) { return 0; } if (Z_TYPE_P(index) == IS_NULL) { ALLOC_INIT_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_string(copy); index = copy; copied = 1; } else { if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) { ALLOC_INIT_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_long(copy); index = copy; copied = 1; } } if ((flags & PH_SEPARATE) == PH_SEPARATE) { if (Z_REFCOUNT_PP(arr) > 1) { zval *new_zv; Z_DELREF_PP(arr); ALLOC_ZVAL(new_zv); INIT_PZVAL_COPY(new_zv, *arr); *arr = new_zv; zval_copy_ctor(new_zv); } } if (Z_TYPE_P(index) == IS_STRING) { exists = zend_hash_del(Z_ARRVAL_PP(arr), Z_STRVAL_P(index), Z_STRLEN_P(index) + 1); } else { exists = zend_hash_index_del(Z_ARRVAL_PP(arr), Z_LVAL_P(index)); } if (copied) { zval_ptr_dtor(©); } return exists; }
/** * Unsets string index from array */ int PHALCON_FASTCALL phalcon_array_unset_string(zval **arr, char *index, uint index_length, int flags) { if (Z_TYPE_PP(arr) != IS_ARRAY) { return 0; } if ((flags & PH_SEPARATE) == PH_SEPARATE) { if (Z_REFCOUNT_PP(arr) > 1) { zval *new_zv; Z_DELREF_PP(arr); ALLOC_ZVAL(new_zv); INIT_PZVAL_COPY(new_zv, *arr); *arr = new_zv; zval_copy_ctor(new_zv); } } return zend_hash_del(Z_ARRVAL_PP(arr), index, index_length); }
static void oauth_provider_apply_custom_param(HashTable *ht, HashTable *custom) /* {{{ */ { HashPosition custompos; zval *entry; zend_string *key; ulong num_key; zend_hash_internal_pointer_reset_ex(custom, &custompos); do { if ((entry = zend_hash_get_current_data_ex(custom, &custompos)) != NULL && HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(custom, &key, &num_key, &custompos)) { if (IS_NULL == Z_TYPE_P(entry)) { zend_hash_del(ht, key); } else { Z_ADDREF_P(entry); zend_hash_update(ht, key, entry); } } } while (SUCCESS==zend_hash_move_forward_ex(custom, &custompos)); }
/* {{{ php_tmpl_set */ int php_tmpl_set(t_template* tmpl, zval* path, zval** data) { zval **iteration, *cp_data, **ztag; t_tmpl_tag *tag; char *p; if(FAILURE == zend_hash_find(Z_ARRVAL_P(tmpl->tags), ZV(path), ZL(path)+1, (void*)&ztag)) { /* php_error(E_NOTICE, "Can't set value for tag/context \"%s\" which doesn't exist", ZV(path)); */ return FAILURE; } tag = Z_TMPL_TAG(ztag); if(TMPL_TAG == tag->typ) { if((iteration = (zval**)php_tmpl_get_iteration(tmpl, path, TMPL_ITERATION_CURRENT)) == NULL) { return FAILURE; } } else { for(p = ZV(path)+ZL(path); p >= ZV(path) && *p != '/'; p--); *(p > ZV(path) ? p++ : ++p) = 0; ZL(path) = strlen(ZV(path)); if((iteration = (zval**)php_tmpl_get_iteration(tmpl, path, TMPL_ITERATION_CURRENT)) == NULL) { return FAILURE; } } convert_to_string_ex(data); MAKE_STD_ZVAL(cp_data); ZVAL_STRINGL(cp_data, Z_STRVAL_PP(data), Z_STRLEN_PP(data), 1); if(SUCCESS == zend_hash_find(Z_ARRVAL_PP(iteration), ZV(tag->name), ZL(tag->name)+1, (void*)&ztag)) { if(IS_ARRAY == Z_TYPE_PP(ztag)) { /* MEMORY LEAK CAUSED BY THE NEXT LINE !!! */ zend_hash_del(Z_ARRVAL_PP(iteration), ZV(tag->name), ZL(tag->name)+1); } else { tmpl->size -= (Z_STRLEN_PP(ztag) * tag->tag_num); } } zend_hash_update(Z_ARRVAL_PP(iteration), ZV(tag->name), ZL(tag->name)+1, (void*)&cp_data, sizeof(zval**), NULL); tmpl->size += (ZL(cp_data) * tag->tag_num); return SUCCESS; }
PHP_METHOD(jz_data, offsetUnset) { zval *readonly = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME_READONLY), 1, NULL); if (Z_TYPE_P(readonly) == IS_FALSE) { zval *props; zend_string *name; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) { return; } props = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL); if (UNEXPECTED(Z_TYPE_P(props) != IS_ARRAY)) { RETURN_FALSE; } if (zend_hash_del(Z_ARRVAL_P(props), name) == SUCCESS) { RETURN_TRUE; } } RETURN_FALSE; }
static int oauth_provider_remove_required_param(HashTable *ht, char *required_param) /* {{{ */ { zval *dest_entry; zend_string *key; ulong num_key; HashPosition hpos; if((dest_entry = zend_hash_str_find(ht, required_param, strlen(required_param))) == NULL) { return FAILURE; } else { zend_hash_internal_pointer_reset_ex(ht, &hpos); do { if(zend_hash_get_current_key_ex(ht, &key, &num_key, &hpos)!=FAILURE) { if(!strcmp(ZSTR_VAL(key), required_param)) { zend_hash_del(ht, key); return SUCCESS; } } } while(zend_hash_move_forward_ex(ht, &hpos)==SUCCESS); } return FAILURE; }
/** {{{ public ZeActiveString::cancel($condition) */ PHP_METHOD(ze_activestring, cancel) { zval * self = NULL; zval * actives = NULL; char * cond = NULL; int cond_len = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s" , &cond, &cond_len ) == FAILURE) { WRONG_PARAM_COUNT; } self = getThis(); actives = zend_read_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), 0 TSRMLS_CC); zend_hash_del(Z_ARRVAL_P(actives), cond, cond_len + 1); zend_update_property(ze_activestring_ce, self, ZEND_STRL(ZE_ACTIVES), actives TSRMLS_CC); RETURN_ZVAL(self, 1, 0); }
/** {{{ proto public Yaf_Config_Simple::offsetUnset($index) */ PHP_METHOD(yaf_config_simple, offsetUnset) { zval *readonly = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME_READONLY), 1, NULL); if (Z_TYPE_P(readonly) == IS_FALSE) { zval *props; zend_string *name; if (zend_parse_parameters(ZEND_NUM_ARGS(), "S", &name) == FAILURE) { return; } props = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL); if (UNEXPECTED(Z_TYPE_P(props) != IS_ARRAY)) { RETURN_FALSE; } if (zend_hash_del(Z_ARRVAL_P(props), name) == SUCCESS) { RETURN_TRUE; } } RETURN_FALSE; }
/** * Unsets zval index from array */ int PHALCON_FASTCALL phalcon_array_unset(zval *arr, zval *index){ zval *copy; int exists, copied = 0; if (Z_TYPE_P(arr) != IS_ARRAY) { return 0; } if (Z_TYPE_P(index) == IS_NULL) { ALLOC_INIT_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_string(copy); index = copy; copied = 1; } else { if (Z_TYPE_P(index) == IS_BOOL || Z_TYPE_P(index) == IS_DOUBLE) { ALLOC_INIT_ZVAL(copy); ZVAL_ZVAL(copy, index, 1, 0); convert_to_long(copy); index = copy; copied = 1; } } if (Z_TYPE_P(index) == IS_STRING) { exists = zend_hash_del(Z_ARRVAL_P(arr), Z_STRVAL_P(index), Z_STRLEN_P(index)+1); } else { exists = zend_hash_index_del(Z_ARRVAL_P(arr), Z_LVAL_P(index)); } if (copied) { zval_ptr_dtor(©); } return exists; }
/* {{{ static int solr_document_remove_field(zval *objptr, solr_char_t *field_name, int field_name_length TSRMLS_DC) */ static int solr_document_remove_field(zval *objptr, solr_char_t *field_name, int field_name_length TSRMLS_DC) { solr_document_t *doc_entry = NULL; if (!field_name_length) { return FAILURE; } /* Retrieve the document entry for the SolrDocument instance */ if (solr_fetch_document_entry(objptr, &doc_entry TSRMLS_CC) == SUCCESS) { if (zend_hash_del(doc_entry->fields, field_name, field_name_length) == SUCCESS) { doc_entry->field_count--; return SUCCESS; } return FAILURE; } return FAILURE; }
/* {{{ php_runkit_import_functions */ static int php_runkit_import_functions(HashTable *function_table, long flags TSRMLS_DC) { HashPosition pos; int i, func_count = zend_hash_num_elements(function_table); zend_hash_internal_pointer_reset_ex(function_table, &pos); for(i = 0; i < func_count; i++) { zend_function *fe = NULL; char *key, *new_key; int key_len, new_key_len, type; long idx; zend_bool add_function = 1; zend_bool exists = 0; zend_hash_get_current_data_ex(function_table, (void**)&fe, &pos); new_key = fe->common.function_name; new_key_len = strlen(new_key) + 1; if (((type = zend_hash_get_current_key_ex(function_table, &key, &key_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT) && fe && fe->type == ZEND_USER_FUNCTION) { if (type == HASH_KEY_IS_STRING) { new_key = key; new_key_len = key_len; exists = zend_hash_exists(EG(function_table), new_key, new_key_len); } else { exists = zend_hash_index_exists(EG(function_table), idx); } if (exists) { if (flags & PHP_RUNKIT_IMPORT_OVERRIDE) { if (type == HASH_KEY_IS_STRING) { if (zend_hash_del(EG(function_table), new_key, new_key_len) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } else { if (zend_hash_index_del(EG(function_table), idx) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } } else { add_function = 0; } } } if (add_function) { if (zend_hash_add(EG(function_table), new_key, new_key_len, fe, sizeof(zend_function), NULL) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failure importing %s()", fe->common.function_name); #ifdef ZEND_ENGINE_2 destroy_zend_function(fe TSRMLS_CC); #else destroy_end_function(fe); #endif return FAILURE; } else { fe->op_array.static_variables = NULL; (*fe->op_array.refcount)++; } } zend_hash_move_forward_ex(function_table, &pos); } return SUCCESS; }
PHPAPI int php_unregister_info_logo(char *logo_string) { return zend_hash_del(&phpinfo_logo_hash, logo_string, strlen(logo_string)); }
static void php_swoole_aio_onComplete(swAio_event *event) { int isEOF = SW_FALSE; int64_t ret; zval *retval = NULL, *zcallback = NULL, *zwriten = NULL; zval *zcontent = NULL; zval **args[2]; file_request *file_req = NULL; dns_request *dns_req = NULL; TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL); if (event->type == SW_AIO_DNS_LOOKUP) { dns_req = (dns_request *) event->req; if (dns_req->callback == NULL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete callback not found[2]"); return; } zcallback = dns_req->callback; } else { if (zend_hash_find(&php_sw_aio_callback, (char *)&(event->fd), sizeof(event->fd), (void**) &file_req) != SUCCESS) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete callback not found[1]"); return; } if (file_req->callback == NULL && file_req->type == SW_AIO_READ) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete callback not found[2]"); return; } zcallback = file_req->callback; } ret = event->ret; if (ret < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: Aio Error: %s[%d]", strerror(event->error), event->error); } else if (file_req != NULL) { if (ret == 0) { bzero(event->buf, event->nbytes); isEOF = SW_TRUE; } else if (file_req->once == 1 && ret < file_req->content_length) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: ret_length[%d] < req->length[%d].", (int) ret, file_req->content_length); } else if (event->type == SW_AIO_READ) { file_req->offset += event->ret; } } if (event->type == SW_AIO_READ) { MAKE_STD_ZVAL(zcontent); args[0] = &file_req->filename; args[1] = &zcontent; ZVAL_STRINGL(zcontent, event->buf, ret, 0); } else if (event->type == SW_AIO_WRITE) { MAKE_STD_ZVAL(zwriten); args[0] = &file_req->filename; args[1] = &zwriten; ZVAL_LONG(zwriten, ret); if (file_req->once != 1) { if (SwooleAIO.mode == SW_AIO_LINUX) { free(event->buf); } else { efree(event->buf); } } } else if(event->type == SW_AIO_DNS_LOOKUP) { MAKE_STD_ZVAL(zcontent); args[0] = &dns_req->domain; if (ret < 0) { ZVAL_STRING(zcontent, "", 0); } else { ZVAL_STRING(zcontent, event->buf, 0); } args[1] = &zcontent; } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete unknow event type"); return; } if (zcallback) { if (call_user_function_ex(EG(function_table), NULL, zcallback, &retval, 2, args, 0, NULL TSRMLS_CC) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: onAsyncComplete handler error"); return; } } //readfile/writefile if (file_req != NULL) { //只操作一次,完成后释放缓存区并关闭文件 if (file_req->once == 1) { close_file: zval_ptr_dtor(&file_req->callback); zval_ptr_dtor(&file_req->filename); if (SwooleAIO.mode == SW_AIO_LINUX) { free(event->buf); } else { efree(event->buf); } close(event->fd); //remove from hashtable zend_hash_del(&php_sw_aio_callback, (char *)&(event->fd), sizeof(event->fd)); } else if(file_req->type == SW_AIO_WRITE) { if (retval != NULL && !Z_BVAL_P(retval)) { swHashMap_del(php_swoole_open_files, Z_STRVAL_P(file_req->filename), Z_STRLEN_P(file_req->filename)); goto close_file; } } else { if (!Z_BVAL_P(retval) || isEOF) { goto close_file; } else if (SwooleAIO.read(event->fd, event->buf, event->nbytes, file_req->offset) < 0) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "swoole_async: continue to read failed. Error: %s[%d]", strerror(event->error), event->error); } } } else if (dns_req != NULL) { zval_ptr_dtor(&dns_req->callback); zval_ptr_dtor(&dns_req->domain); efree(dns_req); efree(event->buf); } if (zcontent != NULL) { efree(zcontent); } if (zwriten != NULL) { zval_ptr_dtor(&zwriten); } if (retval != NULL) { zval_ptr_dtor(&retval); } if (SwooleWG.in_client && SwooleG.main_reactor->event_num == 1 && SwooleAIO.task_num == 1) { SwooleG.running = 0; } }
/* {{{ php_runkit_import_functions */ static int php_runkit_import_functions(HashTable *function_table, long flags TSRMLS_DC) { HashPosition pos; int i, func_count = zend_hash_num_elements(function_table); zend_hash_internal_pointer_reset_ex(function_table, &pos); for(i = 0; i < func_count; i++) { zend_function *fe = NULL; char *key; uint key_len; int type; ulong idx; zend_bool add_function = 1; zend_hash_get_current_data_ex(function_table, (void**)&fe, &pos); if (((type = zend_hash_get_current_key_ex(EG(function_table), &key, &key_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTANT) && fe && fe->type == ZEND_USER_FUNCTION) { if (flags & PHP_RUNKIT_IMPORT_OVERRIDE) { if (type == HASH_KEY_IS_STRING) { if (zend_hash_del(EG(function_table), key, key_len) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } else { if (zend_hash_index_del(EG(function_table), idx) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Inconsistency cleaning up import environment"); return FAILURE; } } } else { add_function = 0; } } if (add_function) { PHP_RUNKIT_FUNCTION_ADD_REF(fe); char *lcase = estrdup(fe->common.function_name); int lcase_len = strlen(lcase); php_strtolower(lcase, lcase_len); if (zend_hash_add(EG(function_table), lcase, lcase_len + 1, fe, sizeof(zend_function), NULL) == FAILURE) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failure importing %s()", fe->common.function_name); #ifdef ZEND_ENGINE_2 destroy_zend_function(fe TSRMLS_CC); #else destroy_end_function(fe); #endif efree(lcase); return FAILURE; } efree(lcase); } zend_hash_move_forward_ex(function_table, &pos); } return SUCCESS; }
/* Must prevent duplicates ... if there are duplicates, replace new by old! */ static void phpdbg_add_watch_collision(phpdbg_watchpoint_t *watch) { phpdbg_watch_collision *cur; /* Check for either recursive or (simple and/or implicit) */ ZEND_ASSERT(((watch->flags & PHPDBG_WATCH_RECURSIVE) == 0) ^ ((watch->flags & (PHPDBG_WATCH_IMPLICIT | PHPDBG_WATCH_SIMPLE)) == 0)); if ((cur = zend_hash_index_find_ptr(&PHPDBG_G(watch_collisions), (zend_ulong) watch->addr.ref))) { phpdbg_watchpoint_t *old; int flags = 0; if ((old = zend_hash_find_ptr(&cur->watches, watch->str)) || (old = zend_hash_find_ptr(&cur->implicit_watches, watch->str))) { if (((old->flags ^ watch->flags) & (PHPDBG_WATCH_NORMAL|PHPDBG_WATCH_IMPLICIT)) == 0) { return; /* there was no change ... */ } flags = old->flags; if (flags & PHPDBG_WATCH_RECURSIVE) { if (!(watch->flags & PHPDBG_WATCH_RECURSIVE) && !--cur->refs) { phpdbg_delete_watchpoints_recursive(watch); } } if (flags & PHPDBG_WATCH_NORMAL) { zend_hash_del(&cur->watches, watch->str); if (zend_hash_num_elements(&cur->watches) > 0) { cur->watch = Z_PTR_P(zend_hash_get_current_data_ex(&cur->watches, NULL)); } else { cur->watch = Z_PTR_P(zend_hash_get_current_data_ex(&cur->implicit_watches, NULL)); } } if (flags & PHPDBG_WATCH_IMPLICIT) { zend_hash_del(&cur->implicit_watches, watch->str); } old->flags = watch->flags; phpdbg_free_watch(watch); efree(watch); watch = old; } if (watch->flags & PHPDBG_WATCH_RECURSIVE) { if (!(flags & PHPDBG_WATCH_RECURSIVE) && !cur->refs++) { phpdbg_create_recursive_zval_watch(watch->parent); } } } else { phpdbg_watch_collision coll; coll.refs = (watch->flags & PHPDBG_WATCH_RECURSIVE) != 0; coll.watch = watch; zend_hash_init(&coll.watches, 8, arghs, NULL, 0); zend_hash_init(&coll.implicit_watches, 8, ..., NULL, 0); cur = zend_hash_index_add_mem(&PHPDBG_G(watch_collisions), (zend_ulong) watch->addr.ref, &coll, sizeof(phpdbg_watch_collision)); phpdbg_store_watchpoint(cur->watch); phpdbg_activate_watchpoint(cur->watch); if (coll.refs) { phpdbg_create_recursive_zval_watch(watch->parent); } } if (watch->flags & PHPDBG_WATCH_NORMAL) { cur->watch = watch; zend_hash_add_ptr(&cur->watches, watch->str, watch->parent); } if (watch->flags & PHPDBG_WATCH_IMPLICIT) { zend_hash_add_ptr(&cur->implicit_watches, watch->str, watch->parent); } }