PHP_METHOD(SolrCollapseFunction, __construct)
{
long int index = SOLR_UNIQUE_FUNCTION_INDEX();
uint nSize = SOLR_INITIAL_HASH_TABLE_SIZE;
solr_function_t *solr_function_dest = NULL;
solr_function_t solr_function;
zval *index_prop, *zvfield = NULL;
solr_char_t *param_name = (solr_char_t *)"field";
int param_name_len = sizeof("field");
solr_string_t field_str;
solr_char_t *field_name = NULL;
int field_name_len = 0;
memset(&solr_function, 0, sizeof(solr_function_t));
if (zend_hash_index_update(SOLR_GLOBAL(functions),index,(void *) &solr_function, sizeof(solr_function_t), (void **) &solr_function_dest) == FAILURE)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error while registering query parameters in HashTable");
return ;
}
index_prop = zend_read_property(Z_OBJCE_P(getThis()), getThis(), SOLR_INDEX_PROPERTY_NAME, sizeof(SOLR_INDEX_PROPERTY_NAME) - 1, 1 TSRMLS_CC);
Z_LVAL_P(index_prop) = index;
solr_function_dest->function_index = index;
solr_function_dest->name = (solr_char_t *)"collapse";
solr_function_dest->name_length = sizeof(solr_function_dest->name);
/* Allocated memory for the params HashTable using fast cache for HashTables */
ALLOC_HASHTABLE(solr_function_dest->params);
zend_hash_init(solr_function_dest->params, nSize, NULL, (dtor_func_t) solr_string_free_ex, SOLR_FUNCTIONS_PERSISTENT);
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &field_name, &field_name_len) == FAILURE)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error Parsing Parameters");
return;
}
if (field_name_len > 0 ) {
memset(&field_str, 0, sizeof(solr_string_t));
solr_string_set(&field_str, (solr_char_t *)field_name, field_name_len);
if(zend_hash_update(solr_function_dest->params, param_name, param_name_len, (void **)&field_str, sizeof(solr_string_t), NULL) == FAILURE)
{
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Error assigning field");
}
}
}
/*{{{ public Fool_Application::run(void)
*/
PHP_METHOD(fool_application,run)
{
zval* response;
zval* dispatcher;
zval* self = getThis();
dispatcher = zend_read_property(fool_application_ce,self,ZEND_STRL(FOOL_APPLICATION_PROPERTY_NAME_DISPATCHER),1 TSRMLS_CC);
if((response = fool_dispatcher_dispatch(dispatcher TSRMLS_CC))){
RETURN_ZVAL(response,1,1);
}
RETURN_FALSE;
}
/** {{{ public ZePageSet::prev()
*/
PHP_METHOD(ze_pageset, prev) {
zval * self = NULL;
zval * end_row = NULL;
zval * current = NULL;
int pre_page = 0;
self = getThis();
current = zend_read_property(ze_pageset_ce, self, ZEND_STRL(ZE_CURRENT), 0 TSRMLS_CC);
pre_page = Z_LVAL_P(current) - 1;
pre_page = (pre_page >= 1) ? pre_page : 1;
RETURN_LONG(pre_page);
}
PHP_METHOD(air_mysql_waiter, step_2) {
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);
zval *m2s = air_arr_find(context, ZEND_STRS("m2s"));
zval *reads = air_arr_find(context, ZEND_STRS("reads"));
zval *waited = air_arr_find(context, ZEND_STRS("waited"));
zval *processed = air_arr_find(context, ZEND_STRS("processed"));
zval *step = air_arr_find(context, ZEND_STRS("step"));
zend_class_entry *mysqli_ce = air_get_ce(ZEND_STRL("mysqli") TSRMLS_CC);
ulong idx;
char *key;
int key_len;
zval *mysqli;
AIR_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(reads), idx, key, key_len, mysqli){
zval *service_id = air_arr_idx_find(m2s, air_mysqli_get_id(mysqli TSRMLS_CC));
zval *service = air_arr_idx_find(services, Z_LVAL_P(service_id));
zval *mysql = zend_read_property(air_async_service_ce, service, ZEND_STRL("_request"), 0 TSRMLS_CC);
zval **trigger_params[2];
zval *event;
MAKE_STD_ZVAL(event);
zval *event_params;
MAKE_STD_ZVAL(event_params);
array_init(event_params);
Z_ADDREF_P(mysqli);
add_next_index_zval(event_params, mysqli);
zval *mysqli_result = NULL;
if(air_mysqli_get_errno(mysqli TSRMLS_CC)){
ZVAL_STRING(event, "error", 1);
}else{
ZVAL_STRING(event, "success", 1);
air_call_method(&mysqli, mysqli_ce, NULL, ZEND_STRL("reap_async_query"), &mysqli_result, 0, NULL TSRMLS_CC);
Z_ADDREF_P(mysqli_result);
add_next_index_zval(event_params, mysqli_result);
}
trigger_params[0] = &event;
trigger_params[1] = &event_params;
zval *results = NULL;
air_call_method(&mysql, air_mysql_ce, NULL, ZEND_STRL("trigger"), &results, 2, trigger_params TSRMLS_CC);
if(results){
add_index_zval(responses, Z_LVAL_P(service_id), results);
}else{
php_error(E_WARNING, "error on trigger event %s with no results", Z_STRVAL_P(event));
}
zend_hash_index_del(Z_ARRVAL_P(services), Z_LVAL_P(service_id));
zval_ptr_dtor(&event);
zval_ptr_dtor(&event_params);
if(mysqli_result){
zval_ptr_dtor(&mysqli_result);
}
zval *mysql_config = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_config"), 0 TSRMLS_CC);
zval *mode = zend_read_property(air_mysql_ce, mysql, ZEND_STRL("_mode"), 0 TSRMLS_CC);
zval **release_params[3] = {&mysqli, &mysql_config, &mode};
air_call_static_method(air_mysql_keeper_ce, "release", NULL, 3, release_params);
}AIR_HASH_FOREACH_END();
zval * activerecord_model_magic_set( zval * model, char * name, int name_len, zval * value )
{
zval ** alias, * retval = NULL;
if( zend_hash_find( Z_ARRVAL_P(zend_read_static_property(activerecord_model_ce, "alias_attribute", 15, 0 TSRMLS_CC)), name, name_len, (void**)&alias ) == SUCCESS )
{
efree( name );
emalloc( name, sizeof( Z_STRVAL_PP(alias) ) );
strncpy( name, Z_STRVAL_PP(alias), Z_STRLEN_PP(alias) );
name_len = Z_STRLEN_PP(alias);
}
else
{
char *method_name;
emalloc( method_name, sizeof(name)+4 );
strcpy( method_name, "set_" );
strcat( method_name, name );
if( activerecord_model_array_search( zend_read_property( activerecord_model_ce, this_ptr, "setters", 7, 0 TSRMLS_CC ), method_name) )
{
zend_call_method( &this_ptr, activerecord_model_ce, NULL, method_name, sizeof(method_name), &retval, 0, NULL, NULL TSRMLS_CC );
efree( name );
RETURN_ZVAL( retval, 0, 0 );
}
}
if( zend_hash_find( Z_ARRVAL_P(zend_read_property(activerecord_model_ce, model, "attributes", 10, 0 TSRMLS_CC)), name, name_len ) == SUCCESS )
{
retval = activerecord_model_assign_attribute( model, name, name_len, value );
}
efree( name );
if( retval == NULL );
// throw new exception
RETURN_ZVAL( retval, 0, 0 );
}
PHP_METHOD(dataserv, insdata) {
int i=0, fstart=1, fend=1;
char * table;
zval * self = getThis();
zval * fields;
table = Z_STRVAL_P(zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("table"), 0 TSRMLS_CC));
fstart = Z_LVAL_P(zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("start"), 0 TSRMLS_CC));
fend = Z_LVAL_P(zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("end"), 0 TSRMLS_CC));
fields = zend_read_property(Z_OBJCE_P(self), self, ZEND_STRL("fields"), 0 TSRMLS_CC);
FILE * fp = NULL;
char path[1024]={0x00};
sprintf(path, "%s.sql", table);
fp = VCWD_FOPEN( path, "ab+" );
if( fp == NULL )
{
php_printf("Open file %s fail:%d.\n", path, errno );
return;
}
fend = fstart+fend;
for( i = fstart ; i <= fend; ++ i )
{
char *output;
output = (char *)emalloc(1024 * 100 * sizeof(char));
memset(output, 0x00, 1024 * 100 * sizeof(char));
getfields(fields, output);
fprintf(fp,"%s\n",output);
efree(output);
if(i%100 == 0) printf("has %d insert into the files.\n", i);
}
// printf("LOAD DATA INFILE '$datadir' INTO TABLE $tablename FIELDS TERMINATED BY ',' ENCLOSED BY '\"' LINES STARTING BY '\\n';\n");
fclose(fp);
}
/* helper method for fetching settings like r, rw etc. either from client or from bucket */
PHPAPI long riak_bucket_local_or_client_setting(zval *client_instance, zval *bucket_instance, long user_value, char *setting_key, int setting_key_len TSRMLS_DC) {
zval *client_value;
zval *bucket_value;
if (user_value != 0) {
return user_value;
}
client_value = zend_read_property(riak_ce_riakClient, client_instance, setting_key, setting_key_len, 0 TSRMLS_CC);
bucket_value = zend_read_property(riak_ce_riakBucket, bucket_instance, setting_key, setting_key_len, 0 TSRMLS_CC);
if (Z_TYPE_P(bucket_value) == IS_LONG) {
return Z_LVAL_P(bucket_value);
}
if (Z_TYPE_P(client_value) == IS_LONG) {
return Z_LVAL_P(client_value);
}
zend_error(E_WARNING, "Setting neither on client nor bucket found, using default value 0");
return 0;
}
/* {{{ proto array Riak\MapReduce\Phase\MapPhase->toArray()
Convert this phase into an array */
PHP_METHOD(Riak_MapReduce_Phase_MapPhase, toArray)
{
zval *zarray, *zfuncarray, *zfunc, *zarg, zname;
zend_bool keep;
MAKE_STD_ZVAL(zarray);
array_init(zarray);
MAKE_STD_ZVAL(zfuncarray);
zfunc = zend_read_property(riak_mr_mapphase_ce, getThis(), "function", sizeof("function")-1, 1 TSRMLS_CC);
ZVAL_STRING(&zname, "toArray", 0);
call_user_function(NULL, &zfunc, &zname, zfuncarray, 0, NULL TSRMLS_CC);
keep = Z_BVAL_P(zend_read_property(riak_mr_mapphase_ce, getThis(), "keep", sizeof("keep")-1, 1 TSRMLS_CC));
if (keep) {
add_assoc_bool_ex(zfuncarray, "keep", sizeof("keep"), 1);
}
add_assoc_zval_ex(zarray, "map", sizeof("map"), zfuncarray);
zarg = zend_read_property(riak_mr_mapphase_ce, getThis(), "arg", sizeof("arg")-1, 1 TSRMLS_CC);
if (Z_TYPE_P(zarg) != IS_NULL) {
add_assoc_zval_ex(zarray, "arg", sizeof("arg"), zarg);
zval_addref_p(zarg);
}
RETURN_ZVAL(zarray, 0, 1);
}
static int money_handler_compare_objects(zval *object1, zval *object2)
{
zval *amount1, *amount2, *currency1, *currency2;
long compare_result;
currency1 = zend_read_property(Z_OBJCE_P(object1), object1, MONEY_PROP_CURRENCY_WS, 0);
currency2 = zend_read_property(Z_OBJCE_P(object2), object2, MONEY_PROP_CURRENCY_WS, 0);
if ((compare_result = Z_OBJ_HANDLER_P(currency1, compare_objects)(currency1, currency2)) != 0) {
zend_throw_exception(CurrencyMismatchException_ce, "Currencies don't match", 0);
return compare_result;
}
amount1 = zend_read_property(Z_OBJCE_P(object1), object1, MONEY_PROP_AMOUNT_WS, 0);
amount2 = zend_read_property(Z_OBJCE_P(object2), object2, MONEY_PROP_AMOUNT_WS, 0);
if (Z_LVAL_P(amount1) == Z_LVAL_P(amount2)) {
return 0;
} else if(Z_LVAL_P(amount1) < Z_LVAL_P(amount2)) {
return -1;
}
return 1;
}
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);
}
/** {{{ public ZeStatus::getName()
*/
PHP_METHOD(ze_status, getName) {
zval * self = NULL;
zval * name = NULL;
self = getThis();
name = zend_read_property(ze_status_ce, self, ZEND_STRL(ZE_NAME), 1 TSRMLS_CC);
if (name) {
RETURN_ZVAL(name, 1, 0);
}
RETURN_NULL();
}
static int websocket_handshake(http_client *client)
{
//HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: %s\r\nSec-WebSocket-Version: %s\r\nKeepAlive: off\r\nContent-Length: 0\r\nServer: ZWebSocket\r\n
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
zval *header = zend_read_property(swoole_http_request_class_entry_ptr, client->zrequest, ZEND_STRL("header"), 1 TSRMLS_CC);
HashTable *ht = Z_ARRVAL_P(header);
zval **pData;
if(zend_hash_find(ht, ZEND_STRS("sec-websocket-key") , (void **) &pData) == FAILURE) {
php_error_docref(NULL TSRMLS_CC, E_WARNING, "header no sec-websocket-key");
return SW_ERR;
}
convert_to_string(*pData);
// swTrace("key: %s len:%d\n", Z_STRVAL_PP(pData), Z_STRLEN_PP(pData));
swString *buf = swString_new(256);
swString_append_ptr(buf, ZEND_STRL("HTTP/1.1 101 Switching Protocols\r\n"));
swString_append_ptr(buf, ZEND_STRL("Upgrade: websocket\r\nConnection: Upgrade\r\n"));
swString *shaBuf = swString_new(Z_STRLEN_PP(pData)+36);
swString_append_ptr(shaBuf, Z_STRVAL_PP(pData), Z_STRLEN_PP(pData));
swString_append_ptr(shaBuf, ZEND_STRL(SW_WEBSOCKET_GUID));
char data_str[20];
// bzero(data_str, sizeof(data_str));
// swTrace("sha1 start:%s\n", shaBuf->str);
sha1(shaBuf->str, (unsigned char *) data_str);
char encoded_value[50];
bzero(encoded_value, sizeof(encoded_value));
// swTrace("base64_encode start:%d\n", sizeof(data_str));
swBase64_encode((unsigned char *) data_str, 20, encoded_value);
// swTrace("base64_encode end:%s %d %d\n", encoded_value, encoded_len, strlen(encoded_value));
char _buf[128];
int n = 0;
n = snprintf(_buf, strlen(encoded_value)+25, "Sec-WebSocket-Accept: %s\r\n", encoded_value);
// efree(data_str);
// efree(encoded_value);
swString_free(shaBuf);
// swTrace("accept value: %s\n", _buf);
swString_append_ptr(buf, _buf, n);
swString_append_ptr(buf, ZEND_STRL("Sec-WebSocket-Version: 13\r\n"));
swString_append_ptr(buf, ZEND_STRL("Server: swoole-websocket\r\n\r\n"));
swTrace("websocket header len:%zd\n%s \n", buf->length, buf->str);
int ret = swServer_tcp_send(SwooleG.serv, client->fd, buf->str, buf->length);
swString_free(buf);
// swTrace("handshake send: %d lenght: %d\n", client->fd, ret);
return ret;
}
static int http_request_on_query_string(php_http_parser *parser, const char *at, size_t length)
{
TSRMLS_FETCH_FROM_CTX(sw_thread_ctx ? sw_thread_ctx : NULL);
http_client *client = parser->data;
char *query = estrndup(at, length);
zval *get;
MAKE_STD_ZVAL(get);
array_init(get);
zend_update_property(swoole_http_request_class_entry_ptr, client->zrequest, ZEND_STRL("get"), get TSRMLS_CC);
sapi_module.treat_data(PARSE_STRING, query, get TSRMLS_CC);
ZEND_SET_SYMBOL(&EG(symbol_table), "_GET", get);
zval *_request = zend_read_property(swoole_http_request_class_entry_ptr, client->zrequest, ZEND_STRL("request"), 1 TSRMLS_CC);
zend_hash_copy(Z_ARRVAL_P(_request), Z_ARRVAL_P(get), NULL, NULL, sizeof(zval));
return 0;
}
ZEND_METHOD(exception, __wakeup)
{
zval value, *pvalue;
zval *object = getThis();
CHECK_EXC_TYPE(ZEND_STR_MESSAGE, IS_STRING);
CHECK_EXC_TYPE(ZEND_STR_STRING, IS_STRING);
CHECK_EXC_TYPE(ZEND_STR_CODE, IS_LONG);
CHECK_EXC_TYPE(ZEND_STR_FILE, IS_STRING);
CHECK_EXC_TYPE(ZEND_STR_LINE, IS_LONG);
CHECK_EXC_TYPE(ZEND_STR_TRACE, IS_ARRAY);
pvalue = zend_read_property(i_get_exception_base(object), object, "previous", sizeof("previous")-1, 1, &value);
if (pvalue && Z_TYPE_P(pvalue) != IS_NULL && (Z_TYPE_P(pvalue) != IS_OBJECT ||
!instanceof_function(Z_OBJCE_P(pvalue), i_get_exception_base(object)) ||
pvalue == object)) {
zend_unset_property(i_get_exception_base(object), object, "previous", sizeof("previous")-1);
}
}
static IPYNotation *get_pinyin_notation(zval *cls)
{
zval *pylink;
IPYNotation *pynotation;
TSRMLS_FETCH();
pylink = zend_read_property(Z_OBJCE_P(cls), cls, ZEND_STRL("_pynotation"), 0 TSRMLS_CC);
pynotation = (IPYNotation *)zend_fetch_resource(&pylink TSRMLS_CC, -1,
PINYIN_NOTATION_LINK_DESC, NULL, 1, le_pinyin_notation_link);
if (!pynotation) {
php_error_docref(NULL TSRMLS_CC,
E_WARNING,
"Wrong resource handler for IPYNotation.");
}
return pynotation;
}
//数组覆盖
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);
}
PHP_METHOD(jz_data, key) {
zval *prop;
zend_string *string;
zend_ulong index;
prop = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL);
zend_hash_get_current_key(Z_ARRVAL_P(prop), &string, &index);
switch(zend_hash_get_current_key_type(Z_ARRVAL_P(prop))) {
case HASH_KEY_IS_LONG:
RETURN_LONG(index);
break;
case HASH_KEY_IS_STRING:
RETURN_STR(zend_string_copy(string));
break;
default:
RETURN_FALSE;
}
}
/** {{{ proto public Yaf_Config_Simple::key(void)
*/
PHP_METHOD(yaf_config_simple, key) {
zval *prop;
zend_string *string;
ulong index;
prop = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL);
zend_hash_get_current_key(Z_ARRVAL_P(prop), &string, &index);
switch(zend_hash_get_current_key_type(Z_ARRVAL_P(prop))) {
case HASH_KEY_IS_LONG:
RETURN_LONG(index);
break;
case HASH_KEY_IS_STRING:
RETURN_STR(zend_string_copy(string));
break;
default:
RETURN_FALSE;
}
}
/** {{{ public ZeRecorder::exec()
*/
PHP_METHOD(ze_recorder, exec) {
zval * self = NULL;
zval * stmt = NULL;
zval * success = NULL;
zval * row_count = NULL;
/* call execute */
/* call rowCount */
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.exec.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) {
zend_call_method(&stmt, NULL, NULL, ZEND_STRL("rowCount"), &row_count, 0, NULL, NULL TSRMLS_CC);
}
zval_dtor(success);
FREE_ZVAL(success);
} while (0);
if (row_count) {
convert_to_long(row_count);
RETURN_ZVAL(row_count, 1, 1);
} else {
RETURN_FALSE;
}
}
/** {{{ proto public Yaf_Config_Simple::get(string $name = NULL)
*/
PHP_METHOD(yaf_config_simple, get) {
zval *ret, *pzval;
zend_string *name = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS(), "|S", &name) == FAILURE) {
return;
}
if (!name) {
RETURN_ZVAL(getThis(), 1, 0);
} else {
zval *properties;
HashTable *hash;
long lval;
double dval;
properties = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL);
hash = Z_ARRVAL_P(properties);
if (is_numeric_string(ZSTR_VAL(name), ZSTR_LEN(name), &lval, &dval, 0) != IS_LONG) {
if ((pzval = zend_hash_find(hash, name)) == NULL) {
RETURN_FALSE;
}
} else {
if ((pzval = zend_hash_index_find(hash, lval)) == NULL) {
RETURN_FALSE;
}
}
if (Z_TYPE_P(pzval) == IS_ARRAY) {
zval rv = {{0}};
if ((ret = yaf_config_simple_format(getThis(), pzval, &rv))) {
RETURN_ZVAL(ret, 1, 1);
} else {
RETURN_NULL();
}
} else {
RETURN_ZVAL(pzval, 1, 0);
}
}
RETURN_FALSE;
}
/** {{{ proto public Yaf_Config_Simple::current(void)
*/
PHP_METHOD(yaf_config_simple, current) {
zval *prop, *pzval, *ret;
prop = zend_read_property(yaf_config_simple_ce, getThis(), ZEND_STRL(YAF_CONFIG_PROPERT_NAME), 1, NULL);
if ((pzval = zend_hash_get_current_data(Z_ARRVAL_P(prop))) == NULL) {
RETURN_FALSE;
}
if (Z_TYPE_P(pzval) == IS_ARRAY) {
zval rv = {{0}};
if ((ret = yaf_config_simple_format(getThis(), pzval, &rv))) {
RETURN_ZVAL(ret, 1, 1);
} else {
RETURN_NULL();
}
} else {
RETURN_ZVAL(pzval, 1, 0);
}
}
static yaf_view_t *yaf_dispatcher_init_view(yaf_dispatcher_t *dispatcher, zval *tpl_dir, zval *options, yaf_view_t *ptr) /* {{{ */ {
yaf_view_t *view = zend_read_property(yaf_dispatcher_ce,
dispatcher, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_VIEW), 1, NULL);
if (EXPECTED(IS_OBJECT == Z_TYPE_P(view)
&& instanceof_function(Z_OBJCE_P(view), yaf_view_interface_ce))) {
return view;
}
view = yaf_view_instance(ptr, tpl_dir, options);
if (!view) {
return NULL;
}
zend_update_property(yaf_dispatcher_ce, dispatcher, ZEND_STRL(YAF_DISPATCHER_PROPERTY_NAME_VIEW), view);
zval_ptr_dtor(view);
return view;
}
PHP_METHOD(jz_data, current) {
zval *prop, *pzval, *ret;
prop = zend_read_property(jz_data_class_entry, getThis(), ZEND_STRL(JZ_DATA_PROPERT_NAME), 1, NULL);
if ((pzval = zend_hash_get_current_data(Z_ARRVAL_P(prop))) == NULL) {
RETURN_FALSE;
}
if (Z_TYPE_P(pzval) == IS_ARRAY) {
zval rv = {{0}};
if ((ret = jz_data_format(getThis(), pzval, &rv))) {
RETURN_ZVAL(ret, 1, 1);
} else {
RETURN_NULL();
}
} else {
RETURN_ZVAL(pzval, 1, 0);
}
}
/* {{{ proto MongoDB\WriteResult WriteException::getWriteResult()
Returns the WriteResult from the failed write operation. */
PHP_METHOD(WriteException, getWriteResult)
{
zend_error_handling error_handling;
zval *writeresult;
zend_replace_error_handling(EH_THROW, phongo_exception_from_phongo_domain(PHONGO_ERROR_INVALID_ARGUMENT), &error_handling TSRMLS_CC);
if (zend_parse_parameters_none() == FAILURE) {
zend_restore_error_handling(&error_handling TSRMLS_CC);
return;
}
zend_restore_error_handling(&error_handling TSRMLS_CC);
writeresult = zend_read_property(php_phongo_writeexception_ce, getThis(), ZEND_STRL("writeResult"), 0 TSRMLS_CC);
RETURN_ZVAL(writeresult, 1, 0);
}
/** {{{ zval * yaf_response_get_header(yaf_response_t *response, char *name, uint name_len TSRMLS_DC)
*/
zval * yaf_response_get_header(yaf_response_t *response, char *name, uint name_len TSRMLS_DC) {
zval **ppzval;
zval *zheaders = zend_read_property(yaf_response_ce, response, ZEND_STRL(YAF_RESPONSE_PROPERTY_NAME_HEADER), 1 TSRMLS_CC);
if (IS_ARRAY != Z_TYPE_P(zheaders)) {
return NULL;
}
if (!name_len) {
return zheaders;
}
if (zend_hash_find(Z_ARRVAL_P(zheaders), name, name_len + 1, (void **)&ppzval) == FAILURE) {
return NULL;
}
return *ppzval;
}
ZEND_METHOD( myclass , update_get_member ) //在c扩展中操纵PHP对象的成员
{
php_printf("我是update_get_member方法:\n");
zval *var;
zend_class_entry *ce;
ce = Z_OBJCE_P(getThis());
if( zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &var) == FAILURE )
{
php_printf("Error\n");
RETURN_NULL();
}
zend_update_property(ce, getThis(), "public_var", sizeof("public_var")-1, var TSRMLS_CC);
var = NULL;
var = zend_read_property(ce, getThis(), "public_var", sizeof("public_var")-1, 0 TSRMLS_CC);
php_var_dump(&var, 1 TSRMLS_CC);
}
ZEND_METHOD( alinq_class , Any )
{
zend_fcall_info fci;
zend_fcall_info_cache fci_cache;
zend_class_entry *ce;
ce = Z_OBJCE_P(getThis());
zval *dataSource, *reObj, *reZvalCount,*new_dataSource;
HashTable *arrht;
HashTable *rearrht;
char aReturnType;
int aReturnTypeLen;
int count,reCount;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fci_cache) == FAILURE) {
return;
}
// zval *arrayValues;
zval *ALINQ_CLOSURE_RETURN_TYPE_BOOL;
ALINQ_CLOSURE_RETURN_TYPE_BOOL = zend_read_static_property(ce, "ALINQ_CLOSURE_RETURN_TYPE_BOOL", sizeof("ALINQ_CLOSURE_RETURN_TYPE_BOOL")-1, 0 TSRMLS_DC);
// walu_call_user_function(&arrayValues, getThis(), "GetApplicables", "fl", fci,1);
reObj = GetApplicables(getThis(),fci,fci_cache,1,Z_STRVAL_P(ALINQ_CLOSURE_RETURN_TYPE_BOOL),sizeof(Z_STRVAL_P(ALINQ_CLOSURE_RETURN_TYPE_BOOL)));
//过滤后的元素个数
new_dataSource = zend_read_property(NULL, reObj, "dataSource", sizeof("dataSource")-1, 0 TSRMLS_DC);
// walu_call_user_function(&reZvalCount, NULL, "count", "z", reArr);
// reCount = Z_LVAL_P(reZvalCount);
rearrht = Z_ARRVAL_P(new_dataSource);
reCount = rearrht->nNumOfElements;
if(reCount>0){
RETURN_BOOL(1);
}
RETURN_BOOL(0);
}
/** {{{ public ZeRecorder::lastId()
*/
PHP_METHOD(ze_recorder, lastId) {
zval * self = NULL;
zval * conn = NULL;
char * name = NULL;
int name_len = 0;
zval * name_z = NULL;
zval * lastid = NULL;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s"
, &name, &name_len
) == FAILURE) {
WRONG_PARAM_COUNT;
}
/* call lastInsertId */
self = getThis();
conn = zend_read_property(ze_recorder_ce, self, ZEND_STRL(ZE_PDO_DBH), 0 TSRMLS_CC);
do {
if (!conn || Z_TYPE_P(conn) != IS_OBJECT) {
ze_error(E_ERROR TSRMLS_CC, "recorder.lastId.conn.not_object");
break;
}
ALLOC_INIT_ZVAL(name_z);
ZVAL_STRINGL(name_z, name, name_len, 1);
zend_call_method(&conn, NULL, NULL, ZEND_STRL("lastInsertId"), &lastid, 1, name_z, NULL TSRMLS_CC);
zval_dtor(name_z);
FREE_ZVAL(name_z);
} while (0);
if (lastid) {
convert_to_long(lastid);
RETURN_ZVAL(lastid, 1, 1);
} else {
RETURN_FALSE;
}
}
PHP_METHOD(SpotifyPlaylist, getTrackCreator)
{
int index;
zval *thisptr = getThis(), tempretval, *spotifyobject;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &index) == FAILURE) {
return;
}
spotifyobject = zend_read_property(spotifyplaylist_ce, thisptr, "spotify", strlen("spotify"), NOISY TSRMLS_CC);
spotifyplaylist_object *p = (spotifyplaylist_object*)zend_object_store_get_object(thisptr TSRMLS_CC);
sp_user *user = sp_playlist_track_creator(p->playlist, index);
if (!user) {
RETURN_FALSE;
}
object_init_ex(return_value, spotifyuser_ce);
SPOTIFY_METHOD2(SpotifyUser, __construct, &tempretval, return_value, spotifyobject, user);
}
ZEND_METHOD( alinq_class , ElementAt )
{
zend_class_entry *ce;
zval * dataSource;
zval ** item;
ce = Z_OBJCE_P(getThis());
long at;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l",&at) == FAILURE) {
RETURN_NULL();
}
//读取类变量
// MAKE_STD_ZVAL(dataSource);
dataSource = zend_read_property(ce, getThis(), "dataSource", sizeof("dataSource")-1, 0 TSRMLS_DC);
//调用array_values函数
zval *arrayValues;
walu_call_user_function(&arrayValues, NULL, "array_values", "z", dataSource);
//根据下标返回数组元素
// item = &arrayValues[at];
if(zend_hash_index_find(Z_ARRVAL_P(arrayValues), at, (void **)&item) == FAILURE) {
// php_printf("发现\n");
// zend_error(E_ERROR, "element not found");
RETURN_NULL();
}
RETVAL_ZVAL(*item,1,1);
// php_var_dump(&val);
zval_ptr_dtor(&arrayValues);
// zval_ptr_dtor(item);
return;
}
