//迭代函数 void php_alinq_iterator_key(HashTable *arrht) { for(zend_hash_internal_pointer_reset(arrht); zend_hash_has_more_elements(arrht) == SUCCESS; zend_hash_move_forward(arrht)) { if(zend_hash_has_more_elements(arrht) == SUCCESS){ php_printf("aaaa"); }else{ php_printf("bbbb"); } } }
PHP_COUCHBASE_LOCAL int pcbc_ht_iter_remaining(zval *assoc) { ISARRAY_SANITY(assoc); return ((zend_hash_has_more_elements(Z_ARRVAL_P(assoc)) == SUCCESS) ? 1 : 0); }
zval* air_arr_del_index_el(zval *arr) { HashTable *ht = Z_ARRVAL_P(arr); zval *tmp; MAKE_STD_ZVAL(tmp); array_init(tmp); for( zend_hash_internal_pointer_reset(ht); zend_hash_has_more_elements(ht) == SUCCESS; zend_hash_move_forward(ht) ){ int type; ulong idx; char *key; uint key_len; zval **tmp_data; type = zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, NULL); if(type == HASH_KEY_IS_STRING){ if(zend_hash_get_current_data(ht, (void**)&tmp_data) != FAILURE) { add_assoc_stringl_ex(tmp, key, key_len, Z_STRVAL_PP(tmp_data), Z_STRLEN_PP(tmp_data), 1); } } } return tmp; }
/** * @brief bool Phalcon\Registry::valid() */ PHP_METHOD(Phalcon_Registry, valid){ zval *data; data = phalcon_read_property(getThis(), SL("_data"), PH_NOISY); RETURN_BOOL(zend_hash_has_more_elements(Z_ARRVAL_P(data))); }
/* {{{ proto int symbol.setpoints(array points) Set the points of the symbol ) */ PHP_METHOD(symbolObj, setPoints) { zval *zpoints, **ppzval; HashTable *points_hash = NULL; zval *zobj = getThis(); int index = 0, flag = 0, numelements = 0; php_symbol_object *php_symbol; PHP_MAPSCRIPT_ERROR_HANDLING(TRUE); if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &zpoints) == FAILURE) { PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE); return; } PHP_MAPSCRIPT_RESTORE_ERRORS(TRUE); php_symbol = (php_symbol_object *) zend_object_store_get_object(zobj TSRMLS_CC); points_hash = Z_ARRVAL_P(zpoints); numelements = zend_hash_num_elements(points_hash); if ((numelements == 0) || (numelements % 2 != 0)) { mapscript_report_php_error(E_WARNING, "symbol->setpoints : invalid array of %d element(s) as parameter." TSRMLS_CC, numelements); RETURN_LONG(MS_FAILURE); } for(zend_hash_internal_pointer_reset(points_hash); zend_hash_has_more_elements(points_hash) == SUCCESS; zend_hash_move_forward(points_hash)) { zend_hash_get_current_data(points_hash, (void **)&ppzval); if (Z_TYPE_PP(ppzval) != IS_DOUBLE) convert_to_double(*ppzval); if (!flag) { php_symbol->symbol->points[index].x = Z_DVAL_PP(ppzval); php_symbol->symbol->sizex = MS_MAX(php_symbol->symbol->sizex, php_symbol->symbol->points[index].x); } else { php_symbol->symbol->points[index].y = Z_DVAL_PP(ppzval); php_symbol->symbol->sizey = MS_MAX(php_symbol->symbol->sizey, php_symbol->symbol->points[index].y); index++; } flag = !flag; } php_symbol->symbol->numpoints = (numelements/2); RETURN_LONG(MS_SUCCESS); }
/** * Convert a php Array to a map * * @param t the php Array to convert * @return the created map */ map* php_map_from_HasTable(HashTable* t){ #ifdef DEBUG fprintf(stderr,"mapsFromPHPArray start\n"); #endif map* final_res=(map*)malloc(MAP_SIZE); final_res=NULL; char key[1024]; for(zend_hash_internal_pointer_reset(t); zend_hash_has_more_elements(t) == SUCCESS; zend_hash_move_forward(t)) { char *key; uint keylen; ulong idx; int type; int len; zval **ppzval, tmpcopy; type = zend_hash_get_current_key_ex(t, &key, &keylen, &idx, 0, NULL); if (zend_hash_get_current_data(t, (void**)&ppzval) == FAILURE) { /* Should never actually fail * since the key is known to exist. */ continue; } /** * Duplicate the zval so that * the orignal’s contents are not destroyed */ tmpcopy = **ppzval; zval_copy_ctor(&tmpcopy); /** * Reset refcount & Convert */ INIT_PZVAL(&tmpcopy); convert_to_string(&tmpcopy); if(strncmp(key,"value",5)==0){ len=Z_STRLEN_P(&tmpcopy); final_res = addToMapWithSize(final_res,key,Z_STRVAL_P(&tmpcopy),len); } else{ if(final_res==NULL){ #ifdef DEBUG fprintf(stderr,"%s => %s\n",key,Z_STRVAL(tmpcopy)); #endif final_res=createMap(key,Z_STRVAL(tmpcopy)); } else{ #ifdef DEBUG fprintf(stderr,"%s => %s\n",key,Z_STRVAL(tmpcopy)); #endif addToMap(final_res,key,Z_STRVAL(tmpcopy)); } } /* Toss out old copy */ zval_dtor(&tmpcopy); } return final_res; }
PHP_METHOD(Rows, valid) { cassandra_rows* self = NULL; if (zend_parse_parameters_none() == FAILURE) return; self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC); RETURN_BOOL(zend_hash_has_more_elements(Z_ARRVAL_P(self->rows)) == SUCCESS); }
void skyray_http_request_resolve_cookies_if_needed(skyray_http_request_t *self) { if (!ZVAL_IS_NULL(&self->cookie_params)) { return; } zval *lines = skyray_http_message_get_header(&self->message, intern_str_cookie, 0); if (!lines) { return; } array_init(&self->cookie_params); zend_array *ht = Z_ARR_P(lines); zend_array *ht2; zval tmp, *data;; zend_hash_internal_pointer_reset(ht); while(zend_hash_has_more_elements(ht) == SUCCESS) { array_init(&tmp); data = zend_hash_get_current_data(ht); php_explode(intern_str_param_delimiter, Z_STR_P(data), &tmp, ZEND_LONG_MAX); ht2 = Z_ARR_P(&tmp); zend_hash_internal_pointer_reset(ht2); while (zend_hash_has_more_elements(ht2) == SUCCESS) { data = zend_hash_get_current_data(ht2); char *c = strchr(Z_STR_P(data)->val, '='); int len = c - Z_STR_P(data)->val; add_assoc_str_ex(&self->cookie_params, Z_STR_P(data)->val, len, zend_string_init(c + 1, Z_STR_P(data)->len - len - 1, 0)); zend_hash_move_forward(ht2); } zval_ptr_dtor(&tmp); zend_hash_move_forward(ht); } }
static PHP_METHOD(php_midgard_reflection_class, getMethods) { zval *filter = NULL; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &filter) == FAILURE) return; zval *this = getThis(); zval *class_name = NULL; zend_call_method_with_0_params(&this, zend_reflection_class_class, NULL, "getname", &class_name); zval *result = NULL; if (filter) { zend_call_method_with_1_params(&this, zend_reflection_class_class, NULL, "getmethods", &result, filter); } else { zend_call_method_with_0_params(&this, zend_reflection_class_class, NULL, "getmethods", &result); } array_init(return_value); HashTable *parent_ht = Z_ARRVAL_P(result); for( zend_hash_internal_pointer_reset(parent_ht); zend_hash_has_more_elements(parent_ht) == SUCCESS; zend_hash_move_forward(parent_ht) ) { zval **ppzval = NULL; zend_hash_get_current_data(parent_ht, (void**)&ppzval); zval *method_name = NULL; zend_call_method_with_0_params(ppzval, zend_reflection_function_class, NULL, "getname", &method_name); zval *new_obj = NULL; MAKE_STD_ZVAL(new_obj); object_init_ex(new_obj, php_midgard_reflection_method_class); zend_call_method_with_2_params(&new_obj, php_midgard_reflection_method_class, &php_midgard_reflection_method_class->constructor, "__construct", NULL, class_name, method_name ); zval_ptr_dtor(&method_name); add_next_index_zval(return_value, new_obj); } zval_ptr_dtor(&result); zval_ptr_dtor(&class_name); }
char *owsrequest_getenv(const char *name, void *thread_context) { zval **val, **ppzval; zval *cookie_result, *key; HashTable *cookies; char *string_key = NULL, *cookie_tmp; ulong num_key; int numElements, i = 0; TSRMLS_FETCH_FROM_CTX(thread_context); if (STRING_EQUAL(name, "HTTP_COOKIE")) { cookies = PG(http_globals)[TRACK_VARS_COOKIE]->value.ht; numElements = zend_hash_num_elements(cookies); MAKE_STD_ZVAL(cookie_result); ZVAL_STRING(cookie_result, "",1); for(zend_hash_internal_pointer_reset(cookies); zend_hash_has_more_elements(cookies) == SUCCESS; zend_hash_move_forward(cookies), ++i) { zend_hash_get_current_data(cookies, (void **)&ppzval); zend_hash_get_current_key(cookies, &string_key, &num_key, 1); cookie_tmp = malloc((strlen(string_key)+Z_STRLEN_PP(ppzval)+3) * sizeof(char)); sprintf(cookie_tmp, "%s=%s;",string_key,Z_STRVAL_PP(ppzval)); MAKE_STD_ZVAL(key); ZVAL_STRING(key, cookie_tmp,1); add_string_to_string(cookie_result,cookie_result, key); zval_dtor(key); free(cookie_tmp); } return Z_STRVAL_P(cookie_result); } else { zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC); if ( PG(http_globals)[TRACK_VARS_SERVER] && (zend_hash_find(PG(http_globals)[TRACK_VARS_SERVER]->value.ht, name, strlen(name)+1, (void **) &val) == SUCCESS) && (Z_TYPE_PP(val) == IS_STRING)) { return Z_STRVAL_PP(val); } } return NULL; }
void yee_behavior_attach(zval *self, zval *owner) { zend_class_entry *ce = Z_OBJCE_P(self); zval *events = NULL, **handler_ptr; char *event; int event_size; zend_update_property(ce, self, ZEND_STRL("owner"), owner); zend_call_method(&self, ce, NULL, ZEND_STRL("events"), &events, 0, NULL, NULL); if (events && Z_TYPE_P(events) == IS_ARRAY) { HashTable *ht = Z_ARRVAL_P(events); zend_hash_internal_pointer_reset(ht); while(zend_hash_has_more_elements(ht) == SUCCESS) { zend_hash_get_current_key_ex(ht, &event, &event_size, NULL, 0, NULL); zend_hash_get_current_data(ht, (void **)&handler_ptr); zval *zv_event, *zv_handler; MAKE_STD_ZVAL(zv_event); ZVAL_STRINGL(zv_event, event, event_size - 1, 0); if (Z_TYPE_PP(handler_ptr) == IS_STRING) { MAKE_STD_ZVAL(zv_handler); array_init(zv_handler); add_next_index_zval(zv_handler, self); add_next_index_zval(zv_handler, *handler_ptr); zval_addref_p(self); }else { zv_handler = *handler_ptr; } zend_call_method(&owner, Z_OBJCE_P(owner), NULL, ZEND_STRL("on"), NULL, 2, zv_event, zv_handler); efree(zv_event); if (zv_handler != *handler_ptr) { zval_ptr_dtor(&zv_handler); } zend_hash_move_forward(ht); } } zval_ptr_dtor(&events); }
static PHP_FUNCTION(params_array) { HashTable *options = NULL; zval *v; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &v) == FAILURE) { RETURN_FALSE; } options = Z_ARRVAL_P(v);//读取array类型的值 //zend_hash_internal_pointer_reset //zend_hash_has_more_elements 判断HashTable是否有元素 //zend_hash_move_forward 移动HashTable到顶端 //zend_hash_get_current_key_ex 读取HashTable当前的key,HashTable的key有两种,一种是指定字符串,另一种是顺序的0-n下标 //zend_hash_get_current_data 读取HashTable当前的值到zval //zend_hash_get_current_key_type 获取当前key的类型 for(zend_hash_internal_pointer_reset(options); SUCCESS == zend_hash_has_more_elements(options); zend_hash_move_forward(options)) { char *k1; ulong nkey = -1, keylen; zval **z; zend_hash_get_current_key_ex(options, &k1, &keylen, &nkey, 0, NULL); zend_hash_get_current_data(options, (void **)&z); php_printf(" key: "); if (HASH_KEY_IS_STRING == zend_hash_get_current_key_type(options)) { PHPWRITE(k1, keylen); }else{ php_printf("%ld", nkey); } php_printf(" value: "); if (Z_TYPE_P(*z) == IS_STRING) { //php_printf("string(%d)\n", Z_STRLEN_P(*z)); PHPWRITE(Z_STRVAL_P(*z), Z_STRLEN_P(*z)); }else{ zend_print_zval_r((*z), 0 TSRMLS_CC); } php_printf("\n"); } RETURN_TRUE; }
static void call_resolved_handlers(skyray_promise_t *self, zend_array *on_fulfilled, zend_array *on_rejected) { skyray_promise_t *promise = skyray_promise_from_obj(Z_OBJ_P(&self->result)); zend_array *handlers; if (instanceof_function(Z_OBJCE_P(&self->result), skyray_ce_FulfilledPromise)) { handlers = on_fulfilled; } else { handlers = on_rejected; } zend_hash_internal_pointer_reset(handlers); while(zend_hash_has_more_elements(handlers) == SUCCESS) { promise_resolve_context_t *context = zend_hash_get_current_data_ptr(handlers); promise_resolve_context_call(context, &promise->result); zend_hash_move_forward(handlers); } zend_hash_destroy(&self->on_fulfilled); zend_hash_destroy(&self->on_rejcted); }
static int yac_add_multi_impl(char *prefix, uint prefix_len, zval *kvs, int ttl, int add TSRMLS_DC) /* {{{ */ { HashTable *ht = Z_ARRVAL_P(kvs); for (zend_hash_internal_pointer_reset(ht); zend_hash_has_more_elements(ht) == SUCCESS; zend_hash_move_forward(ht)) { char *key; ulong idx; zval **value; uint len, should_free = 0; if (zend_hash_get_current_data(ht, (void **)&value) == FAILURE) { continue; } switch (zend_hash_get_current_key_ex(ht, &key, &len, &idx, 0, NULL)) { case HASH_KEY_IS_LONG: len = spprintf(&key, 0, "%lu", idx) + 1; should_free = 1; case HASH_KEY_IS_STRING: if (yac_add_impl(prefix, prefix_len, key, len - 1, *value, ttl, add TSRMLS_CC)) { if (should_free) { efree(key); } continue; } else { if (should_free) { efree(key); } return 0; } default: continue; } } return 1; }
static int yac_add_multi_impl(char *prefix, uint prefix_len, zval *kvs, int ttl, int add tsrmls_dc) { HashTable *ht = z_arrval_p(kvs); for (zend_hash_internal_pointer_reset(ht); zend_hash_has_more_elements(ht) == success; zend_hash_move_forward(ht)) { char *key; ulong idx; zval **value; uint len, should_free = 0; if (zend_hash_get_current_data(ht, (void **)&value) == FAILURE) { continue; } switch (zend_hash_get_current_key_ex(ht, &key, &len, &idx, 0, null)) { case hash_key_is_long: len = spprintf(&key, 0, "%lu", idx) + 1; should_free = 1; case hash_key_is_string: if (yac_add_impl(prefix, prefix_len, key, len - 1, *value, ttl, add tsrmls_cc)) { if (should_free) { efree(key); } continue; } else { if (should_free) { efree(key); } return 0; } default: continue; } } return 1; }
void cpServer_init(zval *conf, char *ini_file) { size_t group_num = 0; cpShareMemory shm = {0}; shm.size = sizeof (cpServerGS); strncpy(shm.mmap_name, CP_SERVER_MMAP_FILE, strlen(CP_SERVER_MMAP_FILE)); if (cp_create_mmap_file(&shm) == 0) { CPGS = (cpServerGS*) cp_mmap_calloc_with_file(&shm); cpKillClient(); bzero(CPGS, shm.size); if (CPGS == NULL) { php_printf("calloc[1] fail\n"); return; } } else { php_printf("calloc[1] fail\n"); return; } bzero(&CPGL, sizeof (cpServerG)); CPGC.backlog = CP_BACKLOG; // CPGC.reactor_num = CP_CPU_NUM; CPGC.reactor_num = 1; CPGC.timeout_sec = CP_REACTOR_TIMEO_SEC; CPGC.timeout_usec = CP_REACTOR_TIMEO_USEC; CPGC.max_conn = CP_MAX_FDS; CPGC.max_request = CP_MAX_REQUEST; CPGC.idel_time = CP_IDEL_TIME; CPGC.recycle_num = CP_RECYCLE_NUM; CPGC.max_read_len = CP_DEF_MAX_READ_LEN; CPGC.ser_fail_hits = 1; CPGC.max_fail_num = 2; strcpy(CPGC.ini_file, ini_file); // MAKE_STD_ZVAL(CPGS->group); // array_init(CPGS->group); for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(conf)); zend_hash_has_more_elements(Z_ARRVAL_P(conf)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(conf))) { zval **config; zend_hash_get_current_data(Z_ARRVAL_P(conf), (void**) &config); char *name; uint keylen; zend_hash_get_current_key_ex(Z_ARRVAL_P(conf), &name, &keylen, NULL, 0, NULL); if (strcmp(name, "common") == 0) {//common config cpServer_init_common(*config); } else { zval **v; strcpy(CPGS->G[group_num].name, name); if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_min"), (void **) &v) == SUCCESS) { convert_to_long(*v); CPGS->G[group_num].worker_num = CPGS->G[group_num].worker_min = Z_LVAL_PP(v); } if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_max"), (void **) &v) == SUCCESS) { convert_to_long(*v); CPGS->G[group_num].worker_max = Z_LVAL_PP(v); } CPGS->max_buffer_len = CPGC.max_read_len; pthread_mutexattr_t attr; pthread_mutexattr_init(&attr); pthread_mutexattr_setpshared(&attr, PTHREAD_PROCESS_SHARED); if (pthread_mutex_init(&CPGS->G[group_num].mutex_lock, &attr) < 0) { cpLog("pthread_mutex_init error!. Error: %s [%d]", strerror(errno), errno); return; } CPGS->G[group_num].lock = cpMutexLock; CPGS->G[group_num].unLock = cpMutexUnLock; CPGS->G[group_num].tryLock = cpMutexTryLock; // CPGS->G[group_num].WaitList = CPGS->G[group_num].WaitTail = NULL; CPGS->group_num++; group_num++; } } }
static void cpManagerReload(int sig) { zval *group_conf = NULL, **v; group_conf = cpGetConfig(CPGC.ini_file); int gid = 0; zval **gid_ptr = NULL; cpGroup *G = NULL; if (!Z_BVAL_P(group_conf)) { cpLog("parse ini file[%s] reload error!", CPGC.ini_file); } else { for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(group_conf)); zend_hash_has_more_elements(Z_ARRVAL_P(group_conf)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(group_conf))) { zval **config; zend_hash_get_current_data(Z_ARRVAL_P(group_conf), (void**) &config); char *name; uint keylen; zend_hash_get_current_key_ex(Z_ARRVAL_P(group_conf), &name, &keylen, NULL, 0, NULL); if (strcmp(name, "common") != 0) { if (zend_hash_find(Z_ARRVAL_P(CPGS->group), name, strlen(name) + 1, (void **) &gid_ptr) == SUCCESS) { gid = Z_LVAL_PP(gid_ptr); G = &CPGS->G[gid]; } else { cpLog("can not add datasource when the server runing,if you want add it please restart"); return; } if (pthread_mutex_lock(G->mutex_lock) == 0) { if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_max"), (void **) &v) == SUCCESS) { convert_to_long(*v); G->worker_max = (int) Z_LVAL_PP(v); } if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("pool_min"), (void **) &v) == SUCCESS) { convert_to_long(*v); int new_min = (int) Z_LVAL_PP(v); if (new_min > G->worker_min) {//增加最小 while (G->worker_num < new_min) { cpCreate_worker_mem(G->worker_num, gid); G->workers_status[G->worker_num] = CP_WORKER_IDLE; G->worker_num++; //先加 线程安全 int new_pid = cpFork_one_worker(G->worker_num - 1, gid); if (new_pid < 0) { cpLog("Fork worker process failed. Error: %s [%d]", strerror(errno), errno); } else { G->workers[G->worker_num - 1].pid = new_pid; } } } G->worker_min = new_min; } if (pthread_mutex_unlock(G->mutex_lock) != 0) { cpLog("pthread_mutex_unlock. Error: %s [%d]", strerror(errno), errno); } } } else { if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("recycle_num"), (void **) &v) == SUCCESS) { convert_to_long(*v); CPGC.recycle_num = (int) Z_LVAL_PP(v); } if (zend_hash_find(Z_ARRVAL_PP(config), ZEND_STRS("idel_time"), (void **) &v) == SUCCESS) { convert_to_long(*v); CPGC.idel_time = (int) Z_LVAL_PP(v); } } } zval_ptr_dtor(&group_conf); } }
/** {{{ proto public Yaf_Config_Simple::valid(void) */ PHP_METHOD(yaf_config_simple, valid) { zval *prop = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL); RETURN_BOOL(zend_hash_has_more_elements(Z_ARRVAL_P(prop)) == SUCCESS); }
static bool getMocData(zval* z_this_ptr, const char* classname, const QMetaObject* superdata, QString* meta_stringdata, uint* signature) { /* // - reads all methods defined in a class // - see zend_compile.h for types // - case sensitive // - types need to be matched zend_class_entry* ce_ = Z_OBJCE_P(this_ptr); HashTable* function_table = &Z_OBJCE_P(this_ptr)->function_table; zend_hash_internal_pointer_reset(function_table); zval** prop; union _zend_function *fbc; if (zend_hash_num_elements( function_table ) > 0) { while(zend_hash_has_more_elements(function_table) == SUCCESS) { zend_hash_get_current_data(function_table,(void**)&fbc); zend_hash_move_forward(function_table); QByteArray name( (*fbc).common.function_name ); if( !name.contains("__destruct") && !name.contains("__construct") && !name.contains("__toString") && !name.contains("proxyMethod") && !name.contains("staticProxyMethod") && !name.contains("emit") ){ for( int i=0; i<(*fbc).common.num_args; i++) { qDebug() <<"++ "<< (*fbc).common.arg_info[i].name <<","<< (*fbc).common.arg_info[i].array_type_hint; } qDebug() << (*fbc).common.function_name;// << fbc->internal_function->function_name; } } } */ /// - readout the slots table zval **slotdata; zval *zslot; zslot = zend_read_property(Z_OBJCE_P(z_this_ptr),z_this_ptr,"slots",5,1); zval *zsignal; zsignal = zend_read_property(Z_OBJCE_P(z_this_ptr),z_this_ptr,"signals",7,1); if((zslot)->type==IS_ARRAY && (zsignal)->type==IS_ARRAY ) { HashTable* slots_hash = HASH_OF(zslot); HashTable* signals_hash = HASH_OF(zsignal); char* assocKey; ulong numKey; int signaturecount = 2 + strlen(classname); #ifdef MOC_DEBUG QString qr; pDebug( PHPQt::Moc ) << "+== begin metaobject dump ==+\n"; pDebug( PHPQt::Moc ) << "\t" << classname << "\n\t1 0 0 0 " << zend_hash_num_elements(slots_hash)+zend_hash_num_elements(signals_hash) << " 10 0 0 0 0" << endl << endl; #endif /// - write class signature signature[0] = 1; signature[4] = zend_hash_num_elements(slots_hash)+zend_hash_num_elements(signals_hash); signature[5] = 10; /// - write classname meta_stringdata->append(classname); meta_stringdata->append(QChar::Null); meta_stringdata->append(QChar::Null); int i = 10; zend_hash_internal_pointer_reset(signals_hash); while(zend_hash_has_more_elements(signals_hash) == SUCCESS) { /// - read slot from hashtable zend_hash_get_current_key(signals_hash,&assocKey,&numKey,0); zend_hash_get_current_data(signals_hash,(void**)&slotdata); #ifdef MOC_DEBUG qr.append(Z_STRVAL_PP(slotdata)); qr.append(" "); pDebug( PHPQt::Moc ) << "\t" << signaturecount << "8 8 8 0x05 ::s" << endl; #endif meta_stringdata->append(Z_STRVAL_PP(slotdata)); meta_stringdata->append(QChar::Null); zend_hash_move_forward(signals_hash); /// - write signal signature signature[i++] = signaturecount; signature[i++] = 8; signature[i++] = 8; signature[i++] = 8; signature[i++] = 0x05; signaturecount += strlen(Z_STRVAL_PP(slotdata)) + 1; } zend_hash_internal_pointer_reset(slots_hash); while(zend_hash_has_more_elements(slots_hash) == SUCCESS) { /// - read slot from hashtable zend_hash_get_current_key(slots_hash,&assocKey,&numKey,0); zend_hash_get_current_data(slots_hash,(void**)&slotdata); #ifdef MOC_DEBUG qr.append(Z_STRVAL_PP(slotdata)); qr.append(" "); pDebug( PHPQt::Moc ) << "\t" << signaturecount << "8 8 8 0x0a ::s" << endl; #endif meta_stringdata->append(Z_STRVAL_PP(slotdata)); meta_stringdata->append(QChar::Null); zend_hash_move_forward(slots_hash); /// - write slot signature signature[i++] = signaturecount; signature[i++] = 8; signature[i++] = 8; signature[i++] = 8; signature[i++] = 0x0a; signaturecount += strlen(Z_STRVAL_PP(slotdata)) + 1; } // TODO freeing this crashs // efree( assocKey ); #ifdef MOC_DEBUG pDebug( PHPQt::Moc ) << qr << endl; #endif pDebug( PHPQt::Moc ) << "+== end metaobject dump ==+" << endl; return true; } else { return false; } } // getMocData
void dump_dot(void) { int x, print_header, key_type; int *block_num; int c = 0, len = 0, flag_ho; long index, key_len; char *block_name = NULL; char *time_buff = pvt_get_time(); smart_str str_dot_func = {0}; TSRMLS_FETCH(); char *tmp_buff = NULL; tmp_buff = pvt_sprintf(tpl_dot[0], time_buff); fprintf(PVT_G(trace_file_f_dot), "%s", tmp_buff); efree(time_buff); efree(tmp_buff); if (PVT_G(pvt_graph_fold)) { hide_functions(); } /* Iterate through all blocks/nodes */ for (zend_hash_internal_pointer_reset(PVT_G(block_summary)); zend_hash_has_more_elements(PVT_G(block_summary)) == SUCCESS; zend_hash_move_forward(PVT_G(block_summary))) { key_type = zend_hash_get_current_key(PVT_G(block_summary), &block_name, &index, 0); if (key_type == HASH_KEY_IS_STRING) { key_len = strlen(block_name); } zend_hash_get_current_data(PVT_G(block_summary), (void*) &block_num); print_header = 1; int flag_started = 0; int flag_break = 0; int flag_nop = 0; flag_ho = 1; size_t ret_len; /* Iterate through all functions */ for (x = 0; x < PVT_G(funcs)->len; x++) { if (PVT_G(funcs)->file_id[x] == *block_num) { flag_started = 1; if (print_header) { if (PVT_G(funcs)->type[x] == 2 && flag_ho) { char *ret; php_basename( PVT_G(funcs)->file_name[x], strlen(PVT_G(funcs)->file_name[x]), NULL, 0, &ret, &ret_len TSRMLS_CC ); char *escaped_str = php_escape_html_entities( block_name, strlen(block_name), &len, 0, ENT_QUOTES, NULL TSRMLS_CC ); /* Print the block header */ fprintf(PVT_G(trace_file_f_dot), tpl_point_func[0], *block_num, PVT_G(funcs)->line[x], *block_num, PVT_G(funcs)->file_name[x], PVT_G(funcs)->line[x], ret, escaped_str, PVT_G(funcs)->func_id[x] ); flag_ho = 0; efree(ret); efree(escaped_str); } } } if (PVT_G(funcs)->stack[x] <= PVT_G(dot_funcs_i)->file_id[c] && flag_started) { if (0 == print_header) { flag_break = 1; } else { flag_break = 0; } } if (0 == flag_started) { continue; } if ((PVT_G(funcs)->stack[x]-1) != PVT_G(dot_funcs_i)->file_id[c]) { if (!flag_break) { continue; } else { flag_nop = 1; } } if (flag_nop != 1) { flag_nop = 0; if (print_header) { print_header = 0; } if (PVT_G(dot_funcs_i)->empty[c]) { flag_started = 0; break; } /* Check if function repeats */ if (0 == PVT_G(funcs)->hide[x] || !PVT_G(pvt_graph_fold)) { if (2 == PVT_G(funcs)->type[x]) { /* This is USER function */ char *escaped_str = php_escape_html_entities( PVT_G(funcs)->func_name[x], strlen(PVT_G(funcs)->func_name[x]), &len, 0, ENT_QUOTES, NULL TSRMLS_CC ); fprintf(PVT_G(trace_file_f_dot), tpl_point_func[1], PVT_G(funcs)->line[x], PVT_G(funcs)->line[x], escaped_str, PVT_G(funcs)->func_id[x] ); efree(escaped_str); char *tmp_buff = pvt_sprintf( tpl_relation_func[0], *block_num, PVT_G(funcs)->line[x], PVT_G(funcs)->file_id[x], PVT_G(funcs)->file_id[x], PVT_G(funcs)->func_id[x] ); smart_str_appends(&str_dot_func, tmp_buff); efree(tmp_buff); } else { /* This is ZEND function */ char *escaped_str = php_escape_html_entities( PVT_G(funcs)->func_name[x], strlen(PVT_G(funcs)->func_name[x]), &len, 0, ENT_QUOTES, NULL TSRMLS_CC ); fprintf(PVT_G(trace_file_f_dot), tpl_point_func[2], PVT_G(funcs)->line[x], (1 == PVT_G(funcs)->is_evil[x] ? "d63333" : "e0ebcc"), escaped_str, PVT_G(funcs)->func_id[x] ); efree(escaped_str); } } /* end if (0 ==... */ } /* end if (flag_nop... */ if (flag_break) { if (!flag_nop) { flag_break = 0; flag_started = 0; break; } } } /* end for (x... */ c++; fprintf(PVT_G(trace_file_f_dot), "</TABLE>>\n]\n"); } smart_str_0(&str_dot_func); if (str_dot_func.c != NULL) { fprintf(PVT_G(trace_file_f_dot), "%s", str_dot_func.c); } smart_str_free(&str_dot_func); fprintf(PVT_G(trace_file_f_dot), "\n}\n"); fclose(PVT_G(trace_file_f_dot)); }
zval *air_router_route(air_router_t *self) { zval *return_value; MAKE_STD_ZVAL(return_value); ZVAL_NULL(return_value); pcre_cache_entry *pce; HashTable *ht_or, *ht_cr; zval *original_rules, *compiled_rules, **entry, *r; zval *url; url = zend_read_property(air_router_ce, self, ZEND_STRL("_url"), 0 TSRMLS_CC); original_rules = zend_read_property(air_router_ce, self, ZEND_STRL("_original_rules"), 0 TSRMLS_CC); compiled_rules = zend_read_property(air_router_ce, self, ZEND_STRL("_compiled_rules"), 0 TSRMLS_CC); ht_or = Z_ARRVAL_P(original_rules); ht_cr = Z_ARRVAL_P(compiled_rules); for( /*zend_hash_internal_pointer_reset(ht_or)*/; zend_hash_has_more_elements(ht_or) == SUCCESS; zend_hash_move_forward(ht_or) ){ if (zend_hash_get_current_data(ht_or, (void**)&entry) == FAILURE) { continue; } char *key; uint key_len = 0; ulong idx = 0; smart_str ss = {0}; char *regex = NULL; uint regex_len = 0; //lazy compiling zend_hash_get_current_key_ex(ht_or, &key, &key_len, &idx, 0, NULL); r = air_arr_find(compiled_rules, key, key_len); if (r == NULL){ MAKE_STD_ZVAL(r); array_init(r); regex = air_router_compile(key, key_len, ®ex_len); char *ca = Z_STRVAL_PP(entry); int size = 0; while(size<Z_STRLEN_PP(entry)) { if(ca[size] == '.'){ break; } size++; } if(size==0){ add_assoc_stringl_ex(r, ZEND_STRS(air_c_key), ZEND_STRS("index"), 1); }else{ add_assoc_stringl_ex(r, ZEND_STRS(air_c_key), ca, size, 1); } if(size+1>=Z_STRLEN_PP(entry)){ add_assoc_stringl_ex(r, ZEND_STRS(air_a_key), ZEND_STRS("index"), 1); }else{ add_assoc_stringl_ex(r, ZEND_STRS(air_a_key), ca+size+1, Z_STRLEN_PP(entry)-size-1, 1); } add_assoc_zval_ex(compiled_rules, key, key_len, r); smart_str_appendc(&ss, '#'); smart_str_appendl(&ss, regex, regex_len-1); smart_str_appendc(&ss, '#'); smart_str_0(&ss); efree(regex); add_assoc_stringl_ex(r, ZEND_STRS("regex"), ss.c, ss.len, 1); }else{ zval *r_r = air_arr_find(r, ZEND_STRS("regex")); if (r_r == NULL){ continue; } smart_str_appendl(&ss, Z_STRVAL_P(r_r), Z_STRLEN_P(r_r)); smart_str_0(&ss); } if(ss.len > 0){ zval *ret; pce = pcre_get_compiled_regex_cache(ss.c, ss.len TSRMLS_CC); smart_str_free(&ss); if(pce){ zval matches, *subpats; MAKE_STD_ZVAL(subpats); ZVAL_NULL(subpats); php_pcre_match_impl(pce, Z_STRVAL_P(url), Z_STRLEN_P(url), &matches, subpats/* subpats */, 0/* global */, 0/* ZEND_NUM_ARGS() >= 4 */, 0/*flags PREG_OFFSET_CAPTURE*/, 0/* start_offset */ TSRMLS_CC); if (zend_hash_num_elements(Z_ARRVAL_P(subpats)) > 0) { ret = air_arr_del_index_el(subpats); air_router_route_apply_subpats(r, ret, ZEND_STRS(air_c_key), key, key_len); air_router_route_apply_subpats(r, ret, ZEND_STRS(air_a_key), key, key_len); ZVAL_ZVAL(return_value, ret, 1, 0); zval_ptr_dtor(&ret); zval_ptr_dtor(&subpats); //move forward specially zend_hash_move_forward(ht_or); break; } zval_ptr_dtor(&subpats); } } } return return_value; }
PHP_COUCHBASE_LOCAL void php_couchbase_get_delayed_impl(INTERNAL_FUNCTION_PARAMETERS, int oo) /* {{{ */ { zval *res, *akeys; long with_cas = 0; lcb_time_t exp = {0}; long expiry = 0; zend_bool lock = 0; int argflags = PHP_COUCHBASE_ARG_F_ASYNC; php_couchbase_res *couchbase_res; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2 zend_fcall_info fci = {0}; zend_fcall_info_cache fci_cache = {0}; if (oo) { argflags |= PHP_COUCHBASE_ARG_F_OO; } else { argflags |= PHP_COUCHBASE_ARG_F_FUNCTIONAL; } PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "a|lf!lb", &akeys, &with_cas, &fci, &fci_cache, &expiry, &lock); #else if (oo) { argflags |= PHP_COUCHBASE_ARG_F_OO; } else { argflags |= PHP_COUCHBASE_ARG_F_FUNCTIONAL; } zval *callback = NULL; PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "a|lzlb", &akeys, &with_cas, &callback, &expiry, &lock); if (callback && Z_TYPE_P(callback) != IS_NULL && !zend_is_callable(callback, 0, NULL)) { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo, cb_exception, "third argument is expected to be a valid callback"); return; } #endif { zval **ppzval; lcb_error_t retval; php_couchbase_ctx *ctx; char **keys; long nkey, *klens, i; nkey = zend_hash_num_elements(Z_ARRVAL_P(akeys)); keys = ecalloc(nkey, sizeof(char *)); klens = ecalloc(nkey, sizeof(long)); for (i = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys)), i++) { if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { nkey--; continue; } if (IS_ARRAY != Z_TYPE_PP(ppzval)) { convert_to_string_ex(ppzval); } if (!Z_STRLEN_PP(ppzval)) { nkey--; continue; } if (couchbase_res->prefix_key_len) { klens[i] = spprintf(&(keys[i]), 0, "%s_%s", couchbase_res->prefix_key, Z_STRVAL_PP(ppzval)); } else { keys[i] = Z_STRVAL_PP(ppzval); klens[i] = Z_STRLEN_PP(ppzval); } } if (!nkey) { efree(keys); efree(klens); return; } couchbase_res->seqno += nkey; ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->flags = with_cas; { lcb_get_cmd_t **commands = ecalloc(nkey, sizeof(lcb_get_cmd_t *)); int ii; if (expiry) { exp = pcbc_check_expiry(expiry); } for (ii = 0; ii < nkey; ++ii) { lcb_get_cmd_t *cmd = ecalloc(1, sizeof(lcb_get_cmd_t)); commands[ii] = cmd; cmd->v.v0.key = keys[ii]; cmd->v.v0.nkey = klens[ii]; cmd->v.v0.lock = (int)lock; cmd->v.v0.exptime = exp; /* NB: this assumes that sizeof(lcb_time_t) == sizeof(long) */ } retval = lcb_get(couchbase_res->handle, ctx, nkey, (const lcb_get_cmd_t * const *)commands); for (ii = 0; ii < nkey; ++ii) { efree(commands[ii]); } efree(commands); } if (LCB_SUCCESS != retval) { if (couchbase_res->prefix_key_len) { int i; for (i = 0; i < nkey; i++) { efree(keys[i]); } } efree(keys); efree(klens); efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo, cb_lcb_exception, "Failed to schedule delayed get request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } couchbase_res->async = 1; couchbase_res->async_ctx = ctx; if (couchbase_res->prefix_key_len) { int i; for (i = 0; i < nkey; i++) { efree(keys[i]); } } efree(keys); efree(klens); if ( #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2 fci.size #else callback #endif ) { zval *result, **ppzval, *retval_ptr = NULL; zval **params[2]; MAKE_STD_ZVAL(result); array_init(result); ctx->rv = result; pcbc_start_loop(couchbase_res); couchbase_res->async = 0; for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(result)); zend_hash_has_more_elements(Z_ARRVAL_P(result)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(result))) { if (zend_hash_get_current_data(Z_ARRVAL_P(result), (void **)&ppzval) == FAILURE) { continue; } params[0] = &res; params[1] = ppzval; #if PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 2 fci.retval_ptr_ptr = &retval_ptr; fci.param_count = 2; fci.params = params; zend_call_function(&fci, &fci_cache TSRMLS_CC); #else call_user_function_ex(EG(function_table), NULL, callback, &retval_ptr, 2, params, 0, NULL TSRMLS_CC); #endif if (retval_ptr != NULL) { zval_ptr_dtor(&retval_ptr); } } zval_ptr_dtor(&result); efree(ctx); } } RETURN_TRUE; }
PHP_COUCHBASE_LOCAL void php_couchbase_get_impl(INTERNAL_FUNCTION_PARAMETERS, int multi, int oo, int lock, int touch) { char *key, **keys; long *klens, klen = 0; int nkey = 0; long flag = 0; lcb_time_t exp = {0}; long expiry = 0; zval *res, *cas_token = NULL; int argflags; lcb_error_t retval; php_couchbase_res *couchbase_res; php_couchbase_ctx *ctx; argflags = oo ? PHP_COUCHBASE_ARG_F_OO : PHP_COUCHBASE_ARG_F_FUNCTIONAL; if (multi) { zval *akeys; zval **ppzval; zend_bool preserve_order; int i; if (lock) { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "az|ll", &akeys, &cas_token, &flag, &expiry); } else if (touch) { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "al|z", &akeys, &expiry, &cas_token); } else { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "a|zl", &akeys, &cas_token, &flag); } nkey = zend_hash_num_elements(Z_ARRVAL_P(akeys)); keys = ecalloc(nkey, sizeof(char *)); klens = ecalloc(nkey, sizeof(long)); preserve_order = (flag & COUCHBASE_GET_PRESERVE_ORDER); array_init(return_value); for (i = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys)), i++) { if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { nkey--; continue; } if (IS_ARRAY != Z_TYPE_PP(ppzval)) { convert_to_string_ex(ppzval); } if (!Z_STRLEN_PP(ppzval)) { nkey--; continue; } if (couchbase_res->prefix_key_len) { klens[i] = spprintf(&(keys[i]), 0, "%s_%s", couchbase_res->prefix_key, Z_STRVAL_PP(ppzval)); } else { keys[i] = Z_STRVAL_PP(ppzval); klens[i] = Z_STRLEN_PP(ppzval); } if (preserve_order) { add_assoc_null_ex(return_value, keys[i], klens[i] + 1); } } if (!nkey) { efree(keys); efree(klens); return; } if (cas_token && IS_ARRAY != Z_TYPE_P(cas_token)) { zval_dtor(cas_token); array_init(cas_token); } } else { if (lock) { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "sz|l", &key, &klen, &cas_token, &expiry); } else if (touch) { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "sl|z", &key, &klen, &expiry, &cas_token); } else { PHP_COUCHBASE_GET_PARAMS_WITH_ZV(res, couchbase_res, argflags, "s|z", &key, &klen, &cas_token); } if (!klen) { return; } nkey = 1; if (couchbase_res->prefix_key_len) { klen = spprintf(&key, 0, "%s_%s", couchbase_res->prefix_key, key); } keys = &key; klens = &klen; if (cas_token) { zval_dtor(cas_token); ZVAL_NULL(cas_token); } } { lcb_get_cmd_t **commands = ecalloc(nkey, sizeof(lcb_get_cmd_t *)); int ii; if (expiry) { exp = pcbc_check_expiry(expiry); } for (ii = 0; ii < nkey; ++ii) { lcb_get_cmd_t *cmd = ecalloc(1, sizeof(lcb_get_cmd_t)); commands[ii] = cmd; cmd->v.v0.key = keys[ii]; cmd->v.v0.nkey = klens[ii]; cmd->v.v0.lock = (int)lock; cmd->v.v0.exptime = exp; /* NB: this assumes sizeof(lcb_time_t) == sizeof(long) */ } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; ctx->cas = cas_token; retval = lcb_get(couchbase_res->handle, ctx, nkey, (const lcb_get_cmd_t * const *)commands); for (ii = 0; ii < nkey; ++ii) { efree(commands[ii]); } efree(commands); if (LCB_SUCCESS != retval) { if (couchbase_res->prefix_key_len) { int i; for (i = 0; i < nkey; i++) { efree(keys[i]); } } if (multi) { efree(keys); efree(klens); zval_dtor(return_value); } efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo, cb_lcb_exception, "Failed to schedule get request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } couchbase_res->seqno += nkey; pcbc_start_loop(couchbase_res); if (LCB_SUCCESS != ctx->res->rc) { if (LCB_KEY_ENOENT != ctx->res->rc) { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, oo, cb_lcb_exception, "Failed to get a value from server: %s", lcb_strerror(couchbase_res->handle, ctx->res->rc)); } } efree(ctx); if (couchbase_res->prefix_key_len) { int i; for (i = 0; i < nkey; i++) { efree(keys[i]); } } if (multi) { efree(keys); efree(klens); } } }
PHP_METHOD(jz_data, valid) { zval *prop = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL); RETURN_BOOL(zend_hash_has_more_elements(Z_ARRVAL_P(prop)) == SUCCESS); }
RedisArray* ra_load_hosts(RedisArray *ra, HashTable *hosts, long retry_interval, zend_bool b_lazy_connect TSRMLS_DC) { int i = 0, host_len; zval *id; char *host, *p; short port; zval *zpData, z_cons, z_ret; RedisSock *redis_sock = NULL; /* function calls on the Redis object */ ZVAL_STRING(&z_cons, "__construct"); /* init connections */ for (zend_hash_internal_pointer_reset(hosts); zend_hash_has_more_elements(hosts) == SUCCESS; zend_hash_move_forward(hosts)) { if ((zpData = zend_hash_get_current_data(hosts)) == NULL || (Z_TYPE_P(zpData) != IS_STRING)) { zval_dtor(&z_cons); efree(ra); return NULL; } ra->hosts[i] = estrdup(Z_STRVAL_P(zpData)); /* default values */ host = Z_STRVAL_P(zpData); host_len = Z_STRLEN_P(zpData); port = 6379; if(((p = strrchr(host, ':')))) { /* found port */ host_len = p - host; port = (short)atoi(p+1); } else if(strchr(host,'/') != NULL) { /* unix socket */ port = -1; } /* create Redis object */ object_init_ex(&ra->redis[i], redis_ce); call_user_function(&redis_ce->function_table, &ra->redis[i], &z_cons, &z_ret, 0, NULL TSRMLS_CC); /* create socket */ redis_sock = redis_sock_create(host, host_len, port, ra->connect_timeout, ra->pconnect, NULL, retry_interval, b_lazy_connect); if (!b_lazy_connect) { /* connect */ redis_sock_server_open(redis_sock, 1 TSRMLS_CC); } /* attach */ id = zend_list_insert(redis_sock, le_redis_sock TSRMLS_CC); add_property_resource(&ra->redis[i], "socket", Z_RES_P(id)); i++; } /* Cleanup constructor zval */ zval_dtor(&z_cons); return ra; }
PHP_COUCHBASE_LOCAL void php_couchbase_store_impl(INTERNAL_FUNCTION_PARAMETERS, lcb_storage_t op, int multi) { lcb_error_t retval; php_couchbase_res *couchbase_res; php_couchbase_ctx *ctx; time_t exp = {0}; unsigned int flags = 0; char *payload, *cas = NULL; size_t payload_len = 0; unsigned long long cas_v = 0; long expire = 0, cas_len = 0; char *key = NULL; if (!multi) { char *key = NULL; zval *value; long klen = 0; PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_FUNCTIONAL, "sz|ls", &key, &klen, &value, &expire, &cas, &cas_len); if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, expire, &exp) == -1) { /* Incorrect expiry time */ return; } if (!klen) { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_illegal_key_exception, "No key specified: Empty key"); return; } if (cas) { char *e; cas_v = (lcb_cas_t)strtoull(cas, &e, 10); if (*e != '\0') { couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_illegal_key_exception, "Invalid CAS specified"); return; } } payload = php_couchbase_zval_to_payload(value, &payload_len, &flags, couchbase_res->serializer, couchbase_res->compressor TSRMLS_CC); if (payload == NULL) { RETURN_FALSE; } if (couchbase_res->prefix_key_len) { klen = spprintf(&key, 0, "%s_%s", couchbase_res->prefix_key, key); } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; couchbase_res->seqno += 1; { lcb_store_cmd_t cmd; lcb_store_cmd_t *commands[] = { &cmd }; memset(&cmd, 0, sizeof(cmd)); cmd.v.v0.operation = op; cmd.v.v0.key = key; cmd.v.v0.nkey = klen; cmd.v.v0.bytes = payload; cmd.v.v0.nbytes = payload_len; cmd.v.v0.flags = flags; cmd.v.v0.exptime = exp; cmd.v.v0.cas = (uint64_t)cas_v; retval = lcb_store(couchbase_res->handle, ctx, 1, (const lcb_store_cmd_t * const *)commands); } efree(payload); if (couchbase_res->prefix_key_len) { efree(key); } if (LCB_SUCCESS != retval) { efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_lcb_exception, "Failed to schedule set request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } } else { /* multi */ zval *akeys, **ppzval; char *key = NULL; uint klen = 0; ulong idx; int key_type, nkey = 0; PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_FUNCTIONAL, "a|l", &akeys, &expire); if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, expire, &exp) == -1) { /* Incorrect expiry time */ return; } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; array_init(ctx->rv); for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys))) { if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { continue; } switch ((key_type = zend_hash_get_current_key(Z_ARRVAL_P(akeys), &key, &idx, 0))) { case HASH_KEY_IS_LONG: spprintf(&key, 0, "%ld", idx); break; case HASH_KEY_IS_STRING: break; default: continue; } if (!(klen = strlen(key))) { continue; } payload = php_couchbase_zval_to_payload(*ppzval, &payload_len, &flags, couchbase_res->serializer, couchbase_res->compressor TSRMLS_CC); if (payload == NULL) { RETURN_FALSE; } if (couchbase_res->prefix_key_len) { char *new_key; klen = spprintf(&new_key, 0, "%s_%s", couchbase_res->prefix_key, key); if (key_type == HASH_KEY_IS_LONG) { efree(key); } key = new_key; } { lcb_store_cmd_t cmd; lcb_store_cmd_t *commands[] = { &cmd }; memset(&cmd, 0, sizeof(cmd)); cmd.v.v0.operation = op; cmd.v.v0.key = key; cmd.v.v0.nkey = klen; cmd.v.v0.bytes = payload; cmd.v.v0.nbytes = payload_len; cmd.v.v0.flags = flags; cmd.v.v0.exptime = exp; retval = lcb_store(couchbase_res->handle, ctx, 1, (const lcb_store_cmd_t * const *)commands); } efree(payload); if (couchbase_res->prefix_key_len || HASH_KEY_IS_LONG == key_type) { efree(key); } if (LCB_SUCCESS != retval) { efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_lcb_exception, "Failed to schedule set request: %s", lcb_strerror(couchbase_res->handle, retval)); return; } nkey++; } if (!nkey) { efree(ctx); return; } couchbase_res->seqno += nkey; } { pcbc_start_loop(couchbase_res); if (IS_ARRAY != Z_TYPE_P(return_value)) { if (LCB_SUCCESS != ctx->res->rc) { RETVAL_FALSE; switch (op) { case LCB_ADD: if (LCB_KEY_EEXISTS == ctx->res->rc) { break; } case LCB_APPEND: case LCB_PREPEND: if (LCB_NOT_STORED == ctx->res->rc) { break; } case LCB_REPLACE: case LCB_SET: if (LCB_KEY_ENOENT == ctx->res->rc) { break; } if (cas && LCB_KEY_EEXISTS == ctx->res->rc) { break; } default: couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0, cb_lcb_exception, "Failed to store a value to server: %s", lcb_strerror(couchbase_res->handle, ctx->res->rc)); break; } } } efree(ctx); } }
/** * Convert a php Array to a maps * * @param t the php Array to convert * @return the created maps */ maps* php_maps_from_Array(HashTable *t){ maps* final_res=NULL; maps* cursor=final_res; char key[1024]; for(zend_hash_internal_pointer_reset(t); zend_hash_has_more_elements(t) == SUCCESS; zend_hash_move_forward(t)) { char *key; uint keylen; ulong idx; int type; zval **ppzval, tmpcopy; type = zend_hash_get_current_key_ex(t, &key, &keylen, &idx, 0, NULL); if (zend_hash_get_current_data(t, (void**)&ppzval) == FAILURE) { /** * Should never actually fail since the key is known to exist. */ continue; } /** * Duplicate the zval so that * the orignal’s contents are not destroyed */ tmpcopy = **ppzval; #ifdef DEBUG fprintf(stderr,"key : %s\n",key); #endif zval_copy_ctor(&tmpcopy); #ifdef DEBUG fprintf(stderr,"key : %s\n",key); #endif /** * Reset refcount & Convert */ INIT_PZVAL(&tmpcopy); //convert_to_string(&tmpcopy); if (type == HASH_KEY_IS_STRING) { /** * String Key / Associative */ cursor=createMaps(key); #ifdef DEBUG fprintf(stderr,"key : %s\n",key); #endif HashTable* t=HASH_OF(*ppzval); #ifdef DEBUG fprintf(stderr,"key : %s\n",key); #endif cursor->content=php_map_from_HasTable(t); cursor->next=NULL; if(final_res==NULL) final_res=dupMaps(&cursor); else{ addMapsToMaps(&final_res,cursor); } freeMaps(&cursor); free(cursor); } #ifdef DEBUG fprintf(stderr,"key : %s\n",key); #endif /** * Toss out old copy */ zval_dtor(&tmpcopy); } return final_res; }
static int yac_add_impl(char *prefix, uint prefix_len, char *key, uint len, zval *value, int ttl, int add TSRMLS_DC) /* {{{ */ { int ret = 0, flag = Z_TYPE_P(value); char *msg, buf[YAC_STORAGE_MAX_KEY_LEN]; time_t tv; if ((len + prefix_len) > YAC_STORAGE_MAX_KEY_LEN) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Key%s can not be longer than %d bytes", prefix_len? "(include prefix)" : "", YAC_STORAGE_MAX_KEY_LEN); return ret; } if (prefix_len) { len = snprintf(buf, sizeof(buf), "%s%s", prefix, key); key = (char *)buf; } tv = time(NULL); switch (Z_TYPE_P(value)) { case IS_NULL: ret = yac_storage_update(key, len, (char *)&flag, sizeof(int), flag, ttl, add, tv); break; case IS_BOOL: case IS_LONG: ret = yac_storage_update(key, len, (char *)&Z_LVAL_P(value), sizeof(long), flag, ttl, add, tv); break; case IS_DOUBLE: ret = yac_storage_update(key, len, (char *)&Z_DVAL_P(value), sizeof(double), flag, ttl, add, tv); break; case IS_STRING: case IS_CONSTANT: { if (Z_STRLEN_P(value) > YAC_G(compress_threshold) || Z_STRLEN_P(value) > YAC_STORAGE_MAX_ENTRY_LEN) { int compressed_len; char *compressed; /* if longer than this, then we can not stored the length in flag */ if (Z_STRLEN_P(value) > YAC_ENTRY_MAX_ORIG_LEN) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Value is too long(%d bytes) to be stored", Z_STRLEN_P(value)); return ret; } compressed = emalloc(Z_STRLEN_P(value) * 1.05); compressed_len = fastlz_compress(Z_STRVAL_P(value), Z_STRLEN_P(value), compressed); if (!compressed_len || compressed_len > Z_STRLEN_P(value)) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Compression failed"); efree(compressed); return ret; } if (compressed_len > YAC_STORAGE_MAX_ENTRY_LEN) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Value is too long(%d bytes) to be stored", Z_STRLEN_P(value)); efree(compressed); return ret; } flag |= YAC_ENTRY_COMPRESSED; flag |= (Z_STRLEN_P(value) << YAC_ENTRY_ORIG_LEN_SHIT); ret = yac_storage_update(key, len, compressed, compressed_len, flag, ttl, add, tv); efree(compressed); } else { ret = yac_storage_update(key, len, Z_STRVAL_P(value), Z_STRLEN_P(value), flag, ttl, add, tv); } } break; case IS_ARRAY: case IS_CONSTANT_ARRAY: case IS_OBJECT: { smart_str buf = {0}; #if ENABLE_MSGPACK if (yac_serializer_msgpack_pack(value, &buf, &msg TSRMLS_CC)) { #else if (yac_serializer_php_pack(value, &buf, &msg TSRMLS_CC)) { #endif if (buf.len > YAC_G(compress_threshold) || buf.len > YAC_STORAGE_MAX_ENTRY_LEN) { int compressed_len; char *compressed; if (buf.len > YAC_ENTRY_MAX_ORIG_LEN) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Value is too big to be stored"); return ret; } compressed = emalloc(buf.len * 1.05); compressed_len = fastlz_compress(buf.c, buf.len, compressed); if (!compressed_len || compressed_len > buf.len) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Compression failed"); efree(compressed); return ret; } if (compressed_len > YAC_STORAGE_MAX_ENTRY_LEN) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Value is too big to be stored"); efree(compressed); return ret; } flag |= YAC_ENTRY_COMPRESSED; flag |= (buf.len << YAC_ENTRY_ORIG_LEN_SHIT); ret = yac_storage_update(key, len, compressed, compressed_len, flag, ttl, add, tv); efree(compressed); } else { ret = yac_storage_update(key, len, buf.c, buf.len, flag, ttl, add, tv); } smart_str_free(&buf); } else { php_error_docref(NULL TSRMLS_CC, E_WARNING, "Serialization failed"); smart_str_free(&buf); } } break; case IS_RESOURCE: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type 'IS_RESOURCE' cannot be stored"); break; default: php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported valued type to be stored '%d'", flag); break; } return ret; } /* }}} */ static int yac_add_multi_impl(char *prefix, uint prefix_len, zval *kvs, int ttl, int add TSRMLS_DC) /* {{{ */ { HashTable *ht = Z_ARRVAL_P(kvs); for (zend_hash_internal_pointer_reset(ht); zend_hash_has_more_elements(ht) == SUCCESS; zend_hash_move_forward(ht)) { char *key; ulong idx; zval **value; uint len, should_free = 0; if (zend_hash_get_current_data(ht, (void **)&value) == FAILURE) { continue; } switch (zend_hash_get_current_key_ex(ht, &key, &len, &idx, 0, NULL)) { case HASH_KEY_IS_LONG: len = spprintf(&key, 0, "%lu", idx) + 1; should_free = 1; case HASH_KEY_IS_STRING: if (yac_add_impl(prefix, prefix_len, key, len - 1, *value, ttl, add TSRMLS_CC)) { if (should_free) { efree(key); } continue; } else { if (should_free) { efree(key); } return 0; } default: continue; } } return 1; }
PHP_COUCHBASE_LOCAL void php_couchbase_store_multi_impl_oo(INTERNAL_FUNCTION_PARAMETERS) { lcb_error_t retval; php_couchbase_res *couchbase_res; php_couchbase_ctx *ctx; time_t exp = {0}; long expire = 0; zval *akeys; long persist_to = 0; long replicate_to = 0; struct observe_entry *entries; int numkeys; lcb_store_cmd_t *cmds; lcb_store_cmd_t **commands; int ii; PHP_COUCHBASE_GET_PARAMS(couchbase_res, PHP_COUCHBASE_ARG_F_OO, "a|lll", &akeys, &expire, &persist_to, &replicate_to); if (pcbc_check_expiry(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, expire, &exp) == -1) { /* Incorrect expiry time */ return; } if (validate_simple_observe_clause(couchbase_res->handle, persist_to, replicate_to TSRMLS_CC) == -1) { /* Exception already thrown */ return; } numkeys = zend_hash_num_elements(Z_ARRVAL_P(akeys)); if (numkeys == 0) { zend_throw_exception(cb_illegal_key_exception, "No items specified", 0 TSRMLS_CC); return ; } entries = ecalloc(numkeys, sizeof(struct observe_entry)); commands = ecalloc(numkeys, sizeof(lcb_store_cmd_t *)); cmds = ecalloc(numkeys, sizeof(lcb_store_cmd_t)); /* link the command pointers */ for (ii = 0; ii < numkeys; ++ii) { commands[ii] = cmds + ii; } ctx = ecalloc(1, sizeof(php_couchbase_ctx)); ctx->res = couchbase_res; ctx->rv = return_value; array_init(ctx->rv); for (ii = 0, zend_hash_internal_pointer_reset(Z_ARRVAL_P(akeys)); zend_hash_has_more_elements(Z_ARRVAL_P(akeys)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(akeys)), ++ii) { char *key = NULL; uint klen; size_t payload_len = 0; char *payload; unsigned int flags = 0; zval **ppzval; if (zend_hash_get_current_key_type(Z_ARRVAL_P(akeys)) != HASH_KEY_IS_STRING) { int xx; for (xx = 0; xx < ii; ++xx) { efree((void *)cmds[xx].v.v0.bytes); } efree(commands); efree(cmds); efree(ctx); release_entry_array(entries, xx); zend_throw_exception(cb_illegal_key_exception, "Invalid key specified (not a string)", 0 TSRMLS_CC); return ; } zend_hash_get_current_key(Z_ARRVAL_P(akeys), &key, NULL, 0); if ((klen = strlen(key)) == 0) { int xx; for (xx = 0; xx < ii; ++xx) { efree((void *)cmds[xx].v.v0.bytes); } efree(commands); efree(cmds); efree(ctx); release_entry_array(entries, xx); zend_throw_exception(cb_illegal_key_exception, "Invalid key specified (empty string)", 0 TSRMLS_CC); return ; } if (zend_hash_get_current_data(Z_ARRVAL_P(akeys), (void **)&ppzval) == FAILURE) { int xx; for (xx = 0; xx < ii; ++xx) { efree((void *)cmds[xx].v.v0.bytes); } efree(commands); efree(cmds); efree(ctx); release_entry_array(entries, xx); zend_throw_exception(cb_exception, "Failed to get data for key", 0 TSRMLS_CC); return ; } payload = php_couchbase_zval_to_payload(*ppzval, &payload_len, &flags, couchbase_res->serializer, couchbase_res->compressor TSRMLS_CC); if (payload == NULL) { /* Shouldn't we call an exception? */ RETURN_FALSE; } if (couchbase_res->prefix_key_len) { char *new_key; klen = spprintf(&new_key, 0, "%s_%s", couchbase_res->prefix_key, key); key = new_key; } entries[ii].nkey = klen; entries[ii].key = emalloc(klen); memcpy(entries[ii].key, key, klen); cmds[ii].v.v0.operation = LCB_SET; cmds[ii].v.v0.key = entries[ii].key; cmds[ii].v.v0.nkey = klen; cmds[ii].v.v0.bytes = payload; cmds[ii].v.v0.nbytes = payload_len; cmds[ii].v.v0.flags = flags; cmds[ii].v.v0.exptime = exp; if (couchbase_res->prefix_key_len) { efree(key); } } retval = lcb_store(couchbase_res->handle, ctx, numkeys, (const lcb_store_cmd_t * const *)commands); couchbase_res->seqno += numkeys; pcbc_start_loop(couchbase_res); /* * Time to release the payloads... */ for (ii = 0; ii < numkeys; ++ii) { efree((void *)cmds[ii].v.v0.bytes); } efree(cmds); efree(commands); if (LCB_SUCCESS != retval) { efree(ctx); couchbase_report_error(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1, cb_lcb_exception, "Failed to schedule set request: %s", lcb_strerror(couchbase_res->handle, retval)); release_entry_array(entries, numkeys); RETURN_FALSE; } /* * The item was stored successfully. Did the user want to wait until * it was persisted/replicated? */ if (persist_to != 0 || replicate_to != 0) { int ii = 0; for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(return_value)); zend_hash_has_more_elements(Z_ARRVAL_P(return_value)) == SUCCESS; zend_hash_move_forward(Z_ARRVAL_P(return_value)), ++ii) { zval **curr_cas; zend_hash_get_current_data(Z_ARRVAL_P(return_value), (void **)&curr_cas); if (Z_STRLEN_PP(curr_cas)) { entries[ii].cas = strtoull(Z_STRVAL_PP(curr_cas), 0, 10); } else { /* @todo what to do here? */ fprintf(stderr, "wtf!\n"); } } retval = simple_observe(couchbase_res->handle, entries, numkeys, persist_to, replicate_to); couchbase_res->rc = retval; if (retval != LCB_SUCCESS) { if (retval == LCB_ETIMEDOUT) { zend_throw_exception(cb_timeout_exception, "Timed out waiting for the objects to persist", 0 TSRMLS_CC); } else { char errmsg[256]; snprintf(errmsg, sizeof(errmsg), "An error occured while waiting for the objects to persist: %s", lcb_strerror(couchbase_res->handle, retval)); zend_throw_exception(cb_lcb_exception, errmsg, 0 TSRMLS_CC); } } else { int currsize = 4096; char *errmsg = malloc(currsize); int offset = sprintf(errmsg, "The following documents was mutated:"); int errors = 0; for (ii = 0; ii < numkeys; ++ii) { if (entries[ii].mutated) { if ((offset + entries[ii].nkey + 3) > currsize) { char *p = realloc(errmsg, currsize * 2); if (p) { currsize *= 2; errmsg = p; } } if ((offset + entries[ii].nkey + 3) < currsize) { offset += sprintf(errmsg + offset, " \""); memcpy(errmsg + offset, entries[ii].key, entries[ii].nkey); offset += entries[ii].nkey; offset += sprintf(errmsg + offset, "\""); } errors = 1; } } if (errors) { zend_throw_exception(cb_key_mutated_exception, errmsg, 0 TSRMLS_CC); } free(errmsg); } } release_entry_array(entries, numkeys); efree(ctx); }
PHP_METHOD(air_mysql_waiter, step_0) { AIR_INIT_THIS; zval *services = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_services"), 0 TSRMLS_CC); zval *responses = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_responses"), 0 TSRMLS_CC); zval *context = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("_context"), 0 TSRMLS_CC); zend_class_entry *mysqli_ce = air_get_ce(ZEND_STRL("mysqli") TSRMLS_CC); zval *async; MAKE_STD_ZVAL(async); ZVAL_LONG(async, MYSQLI_ASYNC); zval *wait_pool, *m2s; MAKE_STD_ZVAL(wait_pool); array_init(wait_pool); MAKE_STD_ZVAL(m2s); array_init(m2s); zval *service; ulong idx; uint _idx, key_len; char *key; zval *mysqli = NULL; HashTable *ah = Z_ARRVAL_P(services); for(zend_hash_internal_pointer_reset(ah); zend_hash_has_more_elements(ah) == SUCCESS;){ zval **___tmp; if (zend_hash_get_current_data(ah, (void**)&___tmp) == FAILURE) { continue; } if(zend_hash_get_current_key_ex(ah, &key, &key_len, &idx, 0, NULL) != HASH_KEY_IS_STRING) { key = NULL; key_len = 0; } service = *___tmp; if(Z_TYPE_P(service) == IS_NULL){ zend_hash_index_del(ah, idx); continue; } zval *service_id = zend_read_property(air_async_service_ce, service, ZEND_STRL("_id"), 1 TSRMLS_CC); zval *mysql = zend_read_property(air_async_service_ce, service, ZEND_STRL("_request"), 1 TSRMLS_CC); zval *status = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_status"), 0 TSRMLS_CC); if(Z_LVAL_P(status)){ //ignore if the mysql's been executed zend_hash_index_del(ah, idx); continue; } zval *mysql_config = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_config"), 1 TSRMLS_CC); zval *mode = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_mode"), 1 TSRMLS_CC); if(Z_TYPE_P(mode) == IS_NULL){ air_mysql_auto_mode(mysql TSRMLS_CC); mode = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_mode"), 1 TSRMLS_CC); } zval **acquire_params[2] = {&mysql_config, &mode}; mysqli = NULL; air_call_static_method(air_mysql_keeper_ce, "acquire", &mysqli, 2, acquire_params); if(Z_TYPE_P(mysqli) != IS_NULL){ zval **build_params[1] = {&mysqli}; zval *sql = NULL; air_call_method(&mysql, air_mysql_ce, NULL, ZEND_STRL("build"), &sql, 1, build_params TSRMLS_CC); if(sql){ zval **query_params[2] = {&sql, &async}; air_call_method(&mysqli, mysqli_ce, NULL, ZEND_STRL("query"), NULL, 2, query_params TSRMLS_CC); add_next_index_zval(wait_pool, mysqli); Z_ADDREF_P(service_id); add_index_zval(m2s, air_mysqli_get_id(mysqli TSRMLS_CC), service_id); zval_ptr_dtor(&sql); }else{ //should not happen php_error(E_ERROR, "sql not found"); zval_ptr_dtor(&mysqli); } }else{ zval_ptr_dtor(&mysqli); } zend_hash_move_forward(ah); } zval_ptr_dtor(&async); add_assoc_zval(context, "pool", wait_pool); add_assoc_zval(context, "m2s", m2s); add_assoc_long(context, "waited", zend_hash_num_elements(Z_ARRVAL_P(wait_pool))); add_assoc_long(context, "processed", 0); add_assoc_long(context, "step", 1); }