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 critical
bool 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 void
php_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] = ¶ms[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", "ed, field);
onphp_append_zval_to_smart_string(&string, quoted);
zval_ptr_dtor("ed);
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(©);
}
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 );
}
