自学教程：C++ ALLOC_INIT_ZVAL函数代码示例

int phalcon_array_append_string(zval **arr, char *value, int value_length, int separate TSRMLS_DC){	zval *zvalue;	ALLOC_INIT_ZVAL(zvalue);	Z_SET_REFCOUNT_P(zvalue, 0);	ZVAL_STRINGL(zvalue, value, value_length, 1);	return phalcon_array_append(arr, zvalue, separate TSRMLS_CC);}

/** * @brief Appends a string @a value to @a arr * @param[in,out] arr Array * @param value Value * @param value_length Length of the value (usually <tt>strlen(value)</tt>) * @param separate 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 * @throw @c E_WARNING if @a is not an array * @see zephir_array_append() * * Equivalent to <tt>$arr[] = $value</tt> in PHP, where @c $value is a string. */int zephir_array_append_string(zval **arr, char *value, uint value_length, int separate) {	zval *zvalue;	ALLOC_INIT_ZVAL(zvalue);	Z_SET_REFCOUNT_P(zvalue, 0);	ZVAL_STRINGL(zvalue, value, value_length, 1);	return zephir_array_append(arr, zvalue, separate);}

/** * @brief Appends a long integer @a value to @a arr * @param[in,out] arr Array * @param value Value * @param separate 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 * @throw @c E_WARNING if @a is not an array * @see zephir_array_append() * * Equivalent to <tt>$arr[] = $value</tt> in PHP, where @c $value is an integer. */int zephir_array_append_long(zval **arr, long value, int separate) {    zval *zvalue;    ALLOC_INIT_ZVAL(zvalue);    Z_SET_REFCOUNT_P(zvalue, 0);    ZVAL_LONG(zvalue, value);    return zephir_array_append(arr, zvalue, separate ZEPHIR_DEBUG_PARAMS_DUMMY);}

int phalcon_array_append_long(zval **arr, long value, int separate TSRMLS_DC){	zval *zvalue;	ALLOC_INIT_ZVAL(zvalue);	Z_SET_REFCOUNT_P(zvalue, 0);	ZVAL_LONG(zvalue, value);	return phalcon_array_append(arr, zvalue, separate TSRMLS_CC);}

/** {{{ public ZeRecorder::fetchAll() */PHP_METHOD(ze_recorder, fetchAll) {	zval *   self        = NULL;	zval *   stmt        = NULL;	long     style       = 0;	zval *   style_z     = NULL;	zval *   success     = NULL;	zval *   row         = NULL;	/* PDO::FETCH_ASSOC */	style   =   2;	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l"							 , &style							 ) == FAILURE) {		WRONG_PARAM_COUNT;	}	/* call execute */	/* call fetch */	self = getThis();	stmt = zend_read_property(ze_recorder_ce, self, ZEND_STRL(ZE_STMT), 0 TSRMLS_CC);	do {		if (!stmt || Z_TYPE_P(stmt) != IS_OBJECT) {			ze_error(E_ERROR TSRMLS_CC, "recorder.fetch.stmt.not_object");			break;		}		zend_call_method(&stmt, Z_OBJCE_P(stmt), NULL, ZEND_STRL("execute"), &success, 0, NULL, NULL TSRMLS_CC);		if (!success || EG(exception)) {			break;		}		convert_to_boolean(success);		if (Z_BVAL_P(success) == 1) {			ALLOC_INIT_ZVAL(style_z);			ZVAL_LONG(style_z, style);			zend_call_method(&stmt, NULL, NULL, ZEND_STRL("fetchAll"), &row, 1, style_z, NULL TSRMLS_CC);			zval_dtor(style_z);			FREE_ZVAL(style_z);		}		zval_dtor(success);		FREE_ZVAL(success);	} while (0);	if (row) {		RETURN_ZVAL(row, 1, 1);	} else {		RETURN_FALSE;	}}

// time criticalbool PHPQt::qt_metacall(smokephp_object* o, Smoke::Stack args){    Context::setCallType( Context::SlotCall );    const QMetaObject* staticMetaObject = o->meta();    const int _id = args[2].s_int;    const int offset = staticMetaObject->methodOffset();    const QByteArray signature( staticMetaObject->method(_id).signature() );    const QByteArray metaMethodName = signature.left( signature.indexOf("(") );    //! - if we have a slot overridden in php user space: call it    //!   @see InvokeSlot    if( PHPQt::methodExists( o->ce_ptr() , metaMethodName.constData()) ) {        pDebug( PHPQt::Slot ) << " userspace " << signature << o->ce_ptr()->name;        const int count = staticMetaObject->method( args[2].s_int ).parameterTypes().count() + 1;        // zval* zmem = ALLOCA_N(zval, count);        zval** zmem = (zval**) safe_emalloc( sizeof(zval*), count+1, 0);        for( int i=0;i<count;i++ )        {            ALLOC_INIT_ZVAL( zmem[i] );        }        // NOTICE is memory allocation safe here?        InvokeSlot c( o->smoke(), args, o->zval_ptr(), zmem, _id, staticMetaObject, (void**) args[3].s_voidp, metaMethodName );        c.next();        efree(zmem);        return true;    } else {        if ( staticMetaObject->indexOfSlot( signature ) != -1 )        {            pDebug( PHPQt::Slot ) << " C++ " << signature;            // return false means this will be done by smoke            return false;        } else {            // TODO error case for undefined methods, see php_qt proxyMethod            //			const int i = staticMetaObject->indexOfSignal( signature );            //			const int offset = staticMetaObject->methodOffset(); // The offset is the summary of all methods in the class's superclasses            pDebug( PHPQt::Signal ) << signature << staticMetaObject->className() << _id << staticMetaObject->methodOffset();            /* C++ */	//if( _id < offset ) { qWarning() << "got an id smaller than offset"; }            /**            * We go through QMetaObject::activate, because it can either be connected to a C++ Slot or a user space Slot            * cast to a QObject using smoke cast            * */            QObject* ptr = (QObject*) o->smoke()->cast( const_cast<void*>( o->ptr() ), o->classId(), cachedQObjectSmokeId );            void *_b[] = { 0, ((void**) args[3].s_voidp)[1] };            QMetaObject::activate( ptr, staticMetaObject, 0, _b );            return true; // success        }    } // else method exist    return false;}

static voidphp_jq_filter(zval **return_value, jq_state *jq, jv json, int flags TSRMLS_DC){    jv result;    jq_start(jq, jv_copy(json), 0);    if (jv_is_valid(result = jq_next(jq))) {        int multiple = 0;        while (1) {            zval *zv;            ALLOC_INIT_ZVAL(zv);            if (flags == JQ_OPT_RAW) {                if (jv_get_kind(result) == JV_KIND_STRING) {                    ZVAL_STRING(zv, jv_string_value(result), 1);                } else {                    jv dump = jv_dump_string(result, 0);                    if (jv_is_valid(dump)) {                        ZVAL_STRING(zv, jv_string_value(dump), 1);                    }                    jv_free(dump);                }            } else {                php_jv_dump(&zv, result TSRMLS_CC);            }            if (!jv_is_valid(result = jq_next(jq))) {                if (multiple) {                    zend_hash_next_index_insert(Z_ARRVAL_PP(return_value),                                                &zv, sizeof(zv), NULL);                } else {                    ZVAL_ZVAL(*return_value, zv, 1, 1);                }                break;            }            if (!multiple) {                multiple = 1;                array_init(*return_value);            }            zend_hash_next_index_insert(Z_ARRVAL_PP(return_value),                                        &zv, sizeof(zv), NULL);        }    } else {        jv_free(result);        if (PHP_JQ_G(display_errors)) {            PHP_JQ_ERR(E_WARNING, "filter parse error");        }        ZVAL_BOOL(*return_value, 0);    }}

CPINLINE zval * cp_unserialize(char *data, int len) {    zval *unser_value;    ALLOC_INIT_ZVAL(unser_value);    php_unserialize_data_t var_hash;    PHP_VAR_UNSERIALIZE_INIT(var_hash);    if (php_var_unserialize(&unser_value, (const unsigned char **) &data, (unsigned char *) data + len - 1, &var_hash TSRMLS_CC) != 1)    {//        php_error_docref(NULL TSRMLS_CC, E_NOTICE, "unser data is corrupted");    }    PHP_VAR_UNSERIALIZE_DESTROY(var_hash);    return unser_value;}

static zval * qb_add_array(zval *array, const char *name) {	HashTable *ht = Z_ARRVAL_P(array);	zval *zvalue;	ALLOC_INIT_ZVAL(zvalue);	array_init(zvalue);	if(name) {		zend_hash_update(ht, name, (uint32_t) strlen(name) + 1, &zvalue, sizeof(zval *), NULL);	} else {		zend_hash_next_index_insert(ht, &zvalue, sizeof(zval *), NULL);	}	return zvalue;}

void php_jam_invoke_handler(int type TSRMLS_DC, const char *error_filename, const uint error_lineno, const char *format, ...){	zval *event;	va_list args;	ALLOC_INIT_ZVAL(event);	array_init(event);		va_start(args, format);	php_jam_capture_error_ex(event, type, error_filename, error_lineno, 1, format, args TSRMLS_CC);	va_end(args);}

/** * Call methods that require parameters in a old-style secure way */inline int phalcon_call_method_params_normal(zval *return_value, zval *object, char *method_name, int method_len, zend_uint param_count, zval *params[], int check, int noreturn TSRMLS_DC){	zval *fn = NULL;	int status = FAILURE;	zend_class_entry *ce, *active_scope = NULL;	if (check) {		if (!zend_hash_exists(&Z_OBJCE_P(object)->function_table, method_name, method_len+1)) {			return SUCCESS;		}	}	if (!noreturn) {		ALLOC_INIT_ZVAL(return_value);	}	PHALCON_ALLOC_ZVAL(fn);	ZVAL_STRINGL(fn, method_name, method_len, 1);	if (Z_TYPE_P(object) == IS_OBJECT) {		active_scope = EG(scope);		ce = Z_OBJCE_P(object);		phalcon_find_scope(ce, method_name, method_len TSRMLS_CC);		status = PHALCON_CALL_USER_FUNCTION(&ce->function_table, &object, fn, return_value, param_count, params TSRMLS_CC);		if (status == FAILURE) {			EG(scope) = active_scope;			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined method %s() on class %s", Z_STRVAL_P(fn), Z_OBJCE_P(object)->name);			status = FAILURE;		}		EG(scope) = active_scope;	} else {		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to method %s() on a non object", Z_STRVAL_P(fn));		status = FAILURE;	}	zval_ptr_dtor(&fn);	if (!noreturn) {		zval_ptr_dtor(&return_value);		return_value = NULL;	}	if (EG(exception)){		status = FAILURE;	}	if (status == FAILURE) {		phalcon_memory_restore_stack(TSRMLS_C);	}	return status;}

/** * Call single function which requires arbitrary number of parameters */int phalcon_call_func_params(zval *return_value, char *func_name, int func_length, zend_uint param_count, zval *params[], int noreturn, int fcache_pointer TSRMLS_DC){	zval *fn = NULL;	int status = FAILURE;	//zval ***params_array;	zval *local_retval_ptr = NULL;	//int i;	if (!noreturn) {		ALLOC_INIT_ZVAL(return_value);	}	PHALCON_ALLOC_ZVAL(fn);	ZVAL_STRINGL(fn, func_name, func_length, 1);	/*status = phalcon_cache_lookup_function(fn, fcache_pointer);	if (status == FAILURE) {		return FAILURE;	}*/	/*if(param_count){		params_array = (zval ***) emalloc(sizeof(zval **)*param_count);		for (i=0; i<param_count; i++) {			params_array[i] = &params[i];		}	} else {		params_array = NULL;	}*/	status = call_user_function(CG(function_table), NULL, fn, return_value, param_count, params TSRMLS_CC);	//status = phalcon_call_user_function_ex(CG(function_table), NULL, fn, &local_retval_ptr, param_count, params_array, 1, NULL, phalcon_fcall_cache[fcache_pointer] TSRMLS_CC);	if (status == FAILURE) {		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined function %s()", func_name);		return FAILURE;	}	zval_ptr_dtor(&fn);	if (local_retval_ptr) {		COPY_PZVAL_TO_ZVAL(*return_value, local_retval_ptr);	}	if (!noreturn) {		zval_ptr_dtor(&return_value);	}	/*if (params_array) {		efree(params_array);	}*/	return status;}

static int cpWorker_loop(int worker_id){    CPWG.id = worker_id;    char fifo_name[CP_FIFO_NAME_LEN] = {0};    sprintf(fifo_name, "%s_%d", CP_FIFO_NAME_PRE, CPGC.group_id * CP_GROUP_LEN + worker_id); //client 2 worker    int pipe_fd_read = cpCreateFifo(fifo_name);    sprintf(fifo_name, "%s_%d_1", CP_FIFO_NAME_PRE, CPGC.group_id * CP_GROUP_LEN + worker_id); //worker 2 client    int pipe_fd_write = cpCreateFifo(fifo_name);    CPGS->workers[worker_id].pipe_fd_write = pipe_fd_write;    cpShareMemory *sm_obj = &(CPGS->workers[worker_id].sm_obj);    cpWorkerInfo event;    bzero(&event, sizeof (event));    int ret, len = 0;    int event_len = sizeof (event);    while (CPGS->running) {        zval *ret_value;        ALLOC_INIT_ZVAL(ret_value);        if (CPGS->workers[worker_id].pre_len) {            len = CPGS->workers[worker_id].pre_len;            CPGS->workers[worker_id].pre_len = 0;            CPWG.clientPid = CPGS->workers[worker_id].pre_pid;        } else {            do {                ret = cpFifoRead(pipe_fd_read, &event, event_len);                if (ret < 0) {                    cpLog("fifo read Error: %s [%d]", strerror(errno), errno);                }            } while (event.pid != CPGS->workers[worker_id].CPid); //有可能有脏数据  读出来            if (!CPGS->workers[worker_id].run) {                CPGS->workers[worker_id].pre_len = event.len; //啊~~我要挂了,赶紧存起来 下次再用                CPGS->workers[worker_id].pre_pid = event.pid;                break;            }            len = event.len;//            cpLog("worker %d len",len);            CPWG.clientPid = event.pid;        }        if (sm_obj->mem == NULL) {            if ((sm_obj->mem = shmat(sm_obj->shmid, NULL, 0)) < 0) {                cpLog("attach sys mem error Error: %s [%d]", strerror(errno), errno);            }        }        if (ret < 0) {            cpLog("fifo read Error: %s [%d]", strerror(errno), errno);        }        php_msgpack_unserialize(ret_value, sm_obj->mem, len);        worker_onReceive(ret_value);    }    return SUCCESS;}

/** * Call single static function on a zval which requires parameters */inline int phalcon_call_static_zval_func_params(zval *return_value, zval *mixed_name, char *method_name, int method_len, zend_uint param_count, zval *params[], int noreturn TSRMLS_DC){	zval *fn;	int status = FAILURE;	if (!noreturn) {		ALLOC_INIT_ZVAL(return_value);	}	ALLOC_INIT_ZVAL(fn);	array_init(fn);	add_next_index_zval(fn, mixed_name);	add_next_index_stringl(fn, method_name, method_len, 1);	status = phalcon_call_user_function(CG(function_table), NULL, fn, return_value, param_count, params TSRMLS_CC);	if (status == FAILURE) {		if(Z_TYPE_P(mixed_name) == IS_STRING) {			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined function %s::%s()", Z_STRVAL_P(mixed_name), method_name);		} else {			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Call to undefined function not-callable::%s()", method_name);		}	}	zval_ptr_dtor(&fn);	if (!noreturn) {		zval_ptr_dtor(&return_value);	}	if (EG(exception)) {		status = FAILURE;	}	if (status == FAILURE) {		phalcon_memory_restore_stack(TSRMLS_C);	}	return status;}

PHP_METHOD(SpotifyPlaylist, getTracks){	zval tempretval, *type, *spotifyobject;	ALLOC_INIT_ZVAL(type);	Z_TYPE_P(type) = IS_LONG;	Z_LVAL_P(type) = 0;	spotifyobject = GET_THIS_PROPERTY(spotifyplaylist_ce, "spotify");	object_init_ex(return_value, spotifytrackiterator_ce);	SPOTIFY_METHOD3(SpotifyTrackIterator, __construct, &tempretval, return_value, getThis(), type, spotifyobject);}

ONPHP_METHOD(DBField, toDialectString){	smart_str string = {0};	zval *table, *field, *dialect, *cast, *quoted;		ONPHP_GET_ARGS("O", &dialect, onphp_ce_Dialect);		table = ONPHP_READ_PROPERTY(getThis(), "table");	field = ONPHP_READ_PROPERTY(getThis(), "field");	cast = ONPHP_READ_PROPERTY(getThis(), "cast");		// either null or instance of DialectString	if (Z_TYPE_P(table) == IS_OBJECT) {		zval *tmp;				ONPHP_CALL_METHOD_1(table, "todialectstring", &tmp, dialect);				onphp_append_zval_to_smart_string(&string, tmp);		zval_ptr_dtor(&tmp);		smart_str_appendc(&string, '.');	}		ONPHP_CALL_METHOD_1(dialect, "quotefield", &quoted, field);		onphp_append_zval_to_smart_string(&string, quoted);		zval_ptr_dtor(&quoted);		smart_str_0(&string);		if (Z_STRLEN_P(cast)) {		zval *tmp, *out;				ALLOC_INIT_ZVAL(tmp);				ZVAL_STRINGL(tmp, string.c, string.len, 1);				ONPHP_CALL_METHOD_2_NORET(dialect, "tocasted", &out, tmp, cast);				ZVAL_FREE(tmp);		smart_str_free(&string);				if (EG(exception)) {			return;		}				RETURN_ZVAL(out, 1, 1);	}		RETURN_STRINGL(string.c, string.len, 0);}

/** * Checks a plain text password and its hash version to check if the password matches * * @param string $password * @param string $passwordHash * @param int $maxPasswordLength * @return boolean */PHP_METHOD(Phalcon_Security, checkHash){	zval **password, **password_hash, **max_pass_length = NULL, *hash;	zval* params[2];	int check = 0;	phalcon_fetch_params_ex(2, 1, &password, &password_hash, &max_pass_length);		PHALCON_ENSURE_IS_STRING(password);	if (max_pass_length) {		PHALCON_ENSURE_IS_LONG(max_pass_length);		if (Z_LVAL_PP(max_pass_length) > 0 && Z_STRLEN_PP(password) > Z_LVAL_PP(max_pass_length)) {			RETURN_FALSE;		}	}	params[0] = *password;	params[1] = *password_hash;	ALLOC_INIT_ZVAL(hash);	phalcon_call_func_params_w(hash, SL("crypt"), 2, params TSRMLS_CC);	if (UNEXPECTED(EG(exception) != NULL)) {		zval_ptr_dtor(&hash);		RETURN_NULL();	}	if (UNEXPECTED(Z_TYPE_P(hash) != IS_STRING)) {		convert_to_string(hash);	}	if (Z_STRLEN_P(hash) == Z_STRLEN_PP(password_hash)) {		int n    = Z_STRLEN_P(hash);		char *h1 = Z_STRVAL_P(hash);		char *h2 = Z_STRVAL_PP(password_hash);		while (n) {			check |= ((unsigned int)*h1) ^ ((unsigned int)*h2);			++h1;			++h2;			--n;		}		zval_ptr_dtor(&hash);		RETURN_BOOL(check == 0);	}	zval_ptr_dtor(&hash);	RETURN_FALSE;}

/** * Check whether a model is already initialized * * @param string $modelName * @return bool */PHP_METHOD(Phalcon_Mvc_Collection_Manager, isInitialized){	zval *model_name, *initialized, *lowercased;	phalcon_fetch_params(0, 1, 0, &model_name);		initialized = phalcon_fetch_nproperty_this(this_ptr, SL("_initialized"), PH_NOISY TSRMLS_CC);		ALLOC_INIT_ZVAL(lowercased);	phalcon_fast_strtolower(lowercased, model_name);		RETVAL_BOOL(phalcon_array_isset(initialized, lowercased));	zval_ptr_dtor(&lowercased);}

static void php_jam_user_event_trigger(int type TSRMLS_DC, const char *error_filename, const uint error_lineno, const char *format, ...){	zval *event;	va_list args;	ALLOC_INIT_ZVAL(event);	array_init(event);		add_assoc_bool(event, "jam_event_trigger", 1);		va_start(args, format);	php_jam_capture_error_ex(event, type, error_filename, error_lineno, 1, format, args TSRMLS_CC);	va_end(args);}

/** * 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(&copy);	}	return exists;}

/** * $x[$a][$b]["str"] = $v */void phalcon_array_update_string_zval_zval_multi_3(zval **arr, zval *index1, zval *index2, char *index3, uint index3_length, zval **value, int flags TSRMLS_DC){	zval *temp1 = NULL, *temp2 = NULL;	if (Z_TYPE_PP(arr) == IS_ARRAY) {		ALLOC_INIT_ZVAL(temp1);		phalcon_array_fetch(&temp1, *arr, index1, PH_SILENT_CC);		if (Z_REFCOUNT_P(temp1) > 1) {			phalcon_array_update_zval(arr, index1, &temp1, PH_COPY | PH_CTOR TSRMLS_CC);		}		if (Z_TYPE_P(temp1) != IS_ARRAY) {			convert_to_array(temp1);			phalcon_array_update_zval(arr, index1, &temp1, PH_COPY TSRMLS_CC);		}		ALLOC_INIT_ZVAL(temp2);		phalcon_array_fetch(&temp2, temp1, index2, PH_SILENT_CC);		if (Z_REFCOUNT_P(temp2) > 1) {			phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY | PH_CTOR TSRMLS_CC);		}		if (Z_TYPE_P(temp2) != IS_ARRAY) {			convert_to_array(temp2);			phalcon_array_update_zval(&temp1, index2, &temp2, PH_COPY TSRMLS_CC);		}		phalcon_array_update_string(&temp2, index3, index3_length, value, PH_COPY TSRMLS_CC);	}	if (temp1 != NULL) {		zval_ptr_dtor(&temp1);	}	if (temp2 != NULL) {		zval_ptr_dtor(&temp2);	}}

PHP_METHOD(Money, extractPercentage){	long percentage;	double result;	zval *new_money_percentage, *amount, *new_money_subtotal;	if (zend_parse_parameters(ZEND_NUM_ARGS(), "l", &percentage) == FAILURE) {		return;	}	ALLOC_INIT_ZVAL(new_money_percentage);ALLOC_INIT_ZVAL(new_money_subtotal);	amount = zend_read_property(money_ce, getThis(), MONEY_PROP_AMOUNT_WS, 0);	result = Z_LVAL_P(amount) / (100 + percentage) * percentage;	CREATE_NEW_MONEY_OBJ(new_money_percentage, zend_dval_to_lval(result), zend_read_property(money_ce, getThis(), MONEY_PROP_CURRENCY_WS, 0))	array_init(return_value);	add_assoc_zval(return_value, "percentage", new_money_percentage);	money_handler_do_operation(ZEND_SUB, new_money_subtotal, getThis(), new_money_percentage);	add_assoc_zval(return_value, "subtotal", new_money_subtotal);}

/** * Populate the snapshot results from the observe operations * @param res the couchbase object * @param ocoll the observe collection * @param abools an array (or single) boolean * @param adetails an array of details to be indexed by key * @param multi boolean param - this determines whether abools is a scalar or *  an array */static void oks_populate_results(php_couchbase_res *res,								 struct observe_collection *ocoll,								 zval *abools,								 zval *adetails,								 int multi){	int ii;	if (multi && IS_ARRAY != Z_TYPE_P(abools)) {		array_init(abools);	}	for (ii = 0; ii < ocoll->nks; ii++) {		/* get the key */		pcbc_ht_key reski;		zval *tmpary;		struct observe_keystate *oks = ocoll->ks + ii;		pcbc_ht_key_create(			oks->ocmd.v.v0.key,			oks->ocmd.v.v0.nkey,			&reski);		if (multi) {			pcbc_ht_hkstoreb(abools,							 &reski, oks_get_boolval(oks));		} else {			if (oks_get_boolval(oks)) {				ZVAL_TRUE(abools);			} else {				ZVAL_FALSE(abools);			}		}		if (adetails != NULL) {			ALLOC_INIT_ZVAL(tmpary);			array_init(tmpary);			oks_to_zvarray(oks, tmpary);			pcbc_ht_hkstorez(adetails, &reski, tmpary);		}		pcbc_ht_key_cleanup(&reski);	}}

void dcc_php(struct network *net, struct trigger *trig, struct irc_data *data, struct dcc_session *dcc, const char *dccbuf){	zval *ret;	TSRMLS_FETCH();	ALLOC_INIT_ZVAL(ret);	zend_try	{		if(zend_eval_string_ex(troll_makearg(dccbuf,trig->mask),&ret,"DCC Code",1 TSRMLS_CC) != SUCCESS)		{		}	}}

static zval * qb_add_string(zval *array, const char *name, const char *s, int32_t len) {	HashTable *ht = Z_ARRVAL_P(array);	zval *zvalue;	ALLOC_INIT_ZVAL(zvalue);	if(s) {		if(len == -1) {			len = (int32_t) strlen(s);		}		ZVAL_STRINGL(zvalue, s, len, TRUE);	}	if(name) {		zend_hash_update(ht, name, (uint32_t) strlen(name) + 1, &zvalue, sizeof(zval *), NULL);	} else {		zend_hash_next_index_insert(ht, &zvalue, sizeof(zval *), NULL);	}	return zvalue;}

static int cpWorker_loop(int worker_id, int group_id){    CPWG.id = worker_id;    CPWG.gid = group_id;    cpGroup *G = &CPGS->G[group_id];    char fifo_name[CP_FIFO_NAME_LEN] = {0};    sprintf(fifo_name, "%s_%d", CP_FIFO_NAME_PRE, group_id * CP_GROUP_LEN + worker_id); //client 2 worker    int pipe_fd_read = cpCreateFifo(fifo_name);    sprintf(fifo_name, "%s_%d_1", CP_FIFO_NAME_PRE, group_id * CP_GROUP_LEN + worker_id); //worker 2 client    int pipe_fd_write = cpCreateFifo(fifo_name);    G->workers[worker_id].pipe_fd_write = pipe_fd_write;    cpShareMemory *sm_obj = &(G->workers[worker_id].sm_obj);    cpWorkerInfo event;    bzero(&event, sizeof (event));    int ret, len = 0;    int event_len = sizeof (event);    cpSettitle(G->name);    cpSignalSet(SIGALRM, cpWorker_do_ping, 1, 0);    alarm(CP_PING_SLEEP);    while (CPGS->running)    {        zval *ret_value;        ALLOC_INIT_ZVAL(ret_value);        do        {            ret = cpFifoRead(pipe_fd_read, &event, event_len);            if (ret < 0)            {                cpLog("fifo read Error: %s [%d]", strerror(errno), errno);            }        } while (event.pid != G->workers[worker_id].CPid); //有可能有脏数据  读出来        CPWG.working = 1;        len = event.len;        CPWG.clientPid = event.pid;        if (ret < 0)        {            cpLog("fifo read Error: %s [%d]", strerror(errno), errno);        }        php_msgpack_unserialize(ret_value, sm_obj->mem, len);        worker_onReceive(ret_value);        CPWG.working = 0;    }    return SUCCESS;}

//数组覆盖ZEND_METHOD( alinq_class , Concat ){    zval *concat_array;    zend_class_entry *ce;    ce = Z_OBJCE_P(getThis());    zval * reArrVal;    MAKE_STD_ZVAL(reArrVal);    array_init(reArrVal);    zval *dataSource, **tmpns;    ALLOC_INIT_ZVAL(reArrVal);      //持久化分配内存    if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &concat_array) == FAILURE) {        return;    }         dataSource = zend_read_property(ce, getThis(), "dataSource", sizeof("dataSource")-1, 0 TSRMLS_DC);        //重新copy一个zval，防止破坏原数据        reArrVal = dataSource;        zval_copy_ctor(reArrVal);        // INIT_PZVAL(reArrVal);    while (zend_hash_get_current_data(Z_ARRVAL_P(concat_array), (void **)&tmpns) == SUCCESS) {        char *key;        uint keylen;        ulong idx;        int type;        zval **ppzval, *tmpcopy;        MAKE_STD_ZVAL(tmpcopy);        type = zend_hash_get_current_key_ex(Z_ARRVAL_P(concat_array), &key, &keylen,&idx, 0, NULL);        //重新copy一个zval，防止破坏原数据        tmpcopy = *tmpns;        zval_copy_ctor(tmpcopy);        // INIT_PZVAL(tmpcopy);        add_assoc_zval(reArrVal, key, tmpcopy);         // zval_dtor(&tmpcopy);        // PHPWRITE(key,keylen);          // RETURN_ZVAL(reArrVal,1,1);         zend_hash_move_forward(Z_ARRVAL_P(concat_array));    }        RETURN_ZVAL(reArrVal,1,1);}

static int32_t qb_transfer_arguments_to_php(qb_interpreter_context *cxt) {	USE_TSRM#if !ZEND_ENGINE_2_2 && !ZEND_ENGINE_2_1	void **p = EG(current_execute_data)->prev_execute_data->function_state.arguments;#else	void **p = EG(argument_stack).top_element-1-1;#endif	uint32_t received_argument_count = (uint32_t) (uintptr_t) *p;	uint32_t i;	// copy changes to by-ref arguments	for(i = 0; i < cxt->function->argument_count; i++) {		qb_variable *qvar = cxt->function->variables[i];		if(qvar->flags & QB_VARIABLE_BY_REF) {			if(i < received_argument_count) {				zval **p_zarg = (zval**) p - received_argument_count + i;				zval *zarg = *p_zarg;				if(!qb_transfer_value_to_zval(cxt->function->local_storage, qvar->address, zarg)) {					uint32_t line_id = qb_get_zend_line_id(TSRMLS_C);					qb_append_exception_variable_name(qvar TSRMLS_CC);					qb_set_exception_line_id(line_id TSRMLS_CC);					return FALSE;				}			}		}		qvar->value = NULL;	}	if(EG(return_value_ptr_ptr)) {		// copy value into return variable		zval *ret, **p_ret = EG(return_value_ptr_ptr);		ALLOC_INIT_ZVAL(ret);		*p_ret = ret;		if(cxt->function->return_variable->address) {			if(!qb_transfer_value_to_zval(cxt->function->local_storage, cxt->function->return_variable->address, ret)) {				uint32_t line_id = qb_get_zend_line_id(TSRMLS_C);				qb_append_exception_variable_name(cxt->function->return_variable TSRMLS_CC);				qb_set_exception_line_id(line_id TSRMLS_CC);				return FALSE;			}		}	}	return TRUE;}

static int cli_real_recv(cpMasterInfo *info) {    int pipe_fd_read = get_readfd(info->worker_id);    cpWorkerInfo event;    int ret = 0;    do {        ret = cpFifoRead(pipe_fd_read, &event, sizeof (event));        if (ret < 0) {            zend_error(E_ERROR, "fifo read Error: %s [%d]", strerror(errno), errno);        }    } while (event.pid != cpPid); //有可能有脏数据  读出来    zval *ret_value;    ALLOC_INIT_ZVAL(ret_value);    php_msgpack_unserialize(ret_value, get_attach_buf(info->worker_id,info->semid), event.len);    RecvData.type = event.type;    RecvData.ret_value = ret_value;    return SUCCESS;}

// Add a key-value pair to the hashtable of connection options.void conn_string_parser::add_key_value_pair( const char* value, int len TSRMLS_DC ){    zval_auto_ptr value_z;    ALLOC_INIT_ZVAL( value_z );    if( len == 0 ) {            ZVAL_STRINGL( value_z, "", 0, 1 /*dup*/ );    }    else {        ZVAL_STRINGL( value_z, const_cast<char*>( value ), len, 1 /*dup*/ );    }                    core::sqlsrv_zend_hash_index_update( *ctx, this->conn_options_ht, this->current_key, (void**)&value_z,                                          sizeof(zval*) TSRMLS_CC );    zval_add_ref( &value_z );   }