PHP_METHOD(MIME, load) {
zval *array, *arg, retval;
/* Fetch allowHEAD */
MAKE_STD_ZVAL(array);
array_init_size(array, 2);
add_next_index_stringl(array, "Pancake\\Config", sizeof("Pancake\\Config") - 1, 1);
add_next_index_stringl(array, "get", 3, 1);
MAKE_STD_ZVAL(arg);
Z_TYPE_P(arg) = IS_STRING;
Z_STRLEN_P(arg) = 4;
Z_STRVAL_P(arg) = estrndup("mime", 4);
call_user_function(CG(function_table), NULL, array, &retval, 1, &arg TSRMLS_CC);
if(Z_TYPE(retval) != IS_ARRAY) {
zend_error(E_ERROR, "Bad MIME type array - Please check Pancake MIME type configuration");
}
ALLOC_HASHTABLE(PANCAKE_GLOBALS(mimeTable));
zend_hash_init(PANCAKE_GLOBALS(mimeTable), 0, NULL, ZVAL_PTR_DTOR, 0);
zval **data, **ext;
char *key;
for(zend_hash_internal_pointer_reset(Z_ARRVAL(retval));
zend_hash_get_current_data(Z_ARRVAL(retval), (void**) &data) == SUCCESS &&
zend_hash_get_current_key(Z_ARRVAL(retval), &key, NULL, 0) == HASH_KEY_IS_STRING;
zend_hash_move_forward(Z_ARRVAL(retval))) {
for(zend_hash_internal_pointer_reset(Z_ARRVAL_PP(data));
zend_hash_get_current_data(Z_ARRVAL_PP(data), (void**) &ext) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_PP(data))) {
zval *zkey;
MAKE_STD_ZVAL(zkey);
Z_TYPE_P(zkey) = IS_STRING;
Z_STRLEN_P(zkey) = strlen(key);
Z_STRVAL_P(zkey) = estrndup(key, Z_STRLEN_P(zkey));
zend_hash_add(PANCAKE_GLOBALS(mimeTable), Z_STRVAL_PP(ext), Z_STRLEN_PP(ext), (void*) &zkey, sizeof(zval*), NULL);
}
}
MAKE_STD_ZVAL(PANCAKE_GLOBALS(defaultMimeType));
Z_TYPE_P(PANCAKE_GLOBALS(defaultMimeType)) = IS_STRING;
Z_STRLEN_P(PANCAKE_GLOBALS(defaultMimeType)) = sizeof("application/octet-stream") - 1;
Z_STRVAL_P(PANCAKE_GLOBALS(defaultMimeType)) = estrndup("application/octet-stream", sizeof("application/octet-stream") - 1);
free:
zval_dtor(&retval);
zval_ptr_dtor(&array);
zval_ptr_dtor(&arg);
}
/* {{{ MYSQLI_WARNING *php_get_warnings(MYSQL *mysql) */
MYSQLI_WARNING * php_get_warnings(MYSQLND_CONN_DATA * mysql)
{
MYSQLI_WARNING *w, *first = NULL, *prev = NULL;
MYSQL_RES *result;
zval row;
if (mysql->m->query(mysql, "SHOW WARNINGS", 13)) {
return NULL;
}
result = mysql->m->use_result(mysql, 0);
for (;;) {
zval *entry;
int errno;
mysqlnd_fetch_into(result, MYSQLND_FETCH_NUM, &row, MYSQLND_MYSQLI);
if (Z_TYPE(row) != IS_ARRAY) {
zval_ptr_dtor(&row);
break;
}
zend_hash_internal_pointer_reset(Z_ARRVAL(row));
/* 0. we don't care about the first */
zend_hash_move_forward(Z_ARRVAL(row));
/* 1. Here comes the error no */
entry = zend_hash_get_current_data(Z_ARRVAL(row));
convert_to_long_ex(entry);
errno = Z_LVAL_P(entry);
zend_hash_move_forward(Z_ARRVAL(row));
/* 2. Here comes the reason */
entry = zend_hash_get_current_data(Z_ARRVAL(row));
w = php_new_warning(entry, errno);
/*
Don't destroy entry, because the row destroy will decrease
the refcounter. Decreased twice then mysqlnd_free_result()
will crash, because it will try to access already freed memory.
*/
if (!first) {
first = w;
}
if (prev) {
prev->next = (void *)w;
}
prev = w;
zval_ptr_dtor(&row);
}
mysql_free_result(result);
return first;
}
/** {{{ int yaf_application_is_module_name(char *name, int len TSRMLS_DC)
*/
int yaf_application_is_module_name(char *name, int len TSRMLS_DC) {
zval *modules, **ppzval;
HashTable *ht;
yaf_application_t *app;
app = zend_read_static_property(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_APP), 1 TSRMLS_CC);
if (Z_TYPE_P(app) != IS_OBJECT) {
return 0;
}
modules = zend_read_property(yaf_application_ce, app, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_MODULES), 1 TSRMLS_CC);
if (Z_TYPE_P(modules) != IS_ARRAY) {
return 0;
}
ht = Z_ARRVAL_P(modules);
zend_hash_internal_pointer_reset(ht);
while (zend_hash_get_current_data(ht, (void **)&ppzval) == SUCCESS) {
if (Z_STRLEN_PP(ppzval) == len && strncasecmp(Z_STRVAL_PP(ppzval), name, len) == 0) {
return 1;
}
zend_hash_move_forward(ht);
}
return 0;
}
/**
* Used for seeking on a phar directory handle
*/
static int phar_dir_seek(php_stream *stream, zend_off_t offset, int whence, zend_off_t *newoffset) /* {{{ */
{
HashTable *data = (HashTable *)stream->abstract;
if (!data) {
return -1;
}
if (whence == SEEK_END) {
whence = SEEK_SET;
offset = zend_hash_num_elements(data) + offset;
}
if (whence == SEEK_SET) {
zend_hash_internal_pointer_reset(data);
}
if (offset < 0) {
return -1;
} else {
*newoffset = 0;
while (*newoffset < offset && zend_hash_move_forward(data) == SUCCESS) {
++(*newoffset);
}
return 0;
}
}
/**
* @brief void Phalcon\Registry::next()
*/
PHP_METHOD(Phalcon_Registry, next){
zval data = {};
phalcon_read_property(&data, getThis(), SL("_data"), PH_NOISY);
zend_hash_move_forward(Z_ARRVAL(data));
}
/* {{{ pip_hash_to_list(zval **hash)
Convert a PHP hash to a Python list */
PyObject *
pip_hash_to_list(zval **hash)
{
PyObject *list, *item;
zval **entry;
long pos = 0;
/* Make sure we were given a PHP hash */
if (Z_TYPE_PP(hash) != IS_ARRAY) {
return NULL;
}
/* Create a list with the same number of elements as the hash */
list = PyList_New(zend_hash_num_elements(Z_ARRVAL_PP(hash)));
/* Let's start at the very beginning, a very good place to start. */
zend_hash_internal_pointer_reset(Z_ARRVAL_PP(hash));
/* Iterate over the hash's elements */
while (zend_hash_get_current_data(Z_ARRVAL_PP(hash),
(void **)&entry) == SUCCESS) {
/* Convert the PHP value to its Python equivalent */
item = pip_zval_to_pyobject(entry);
/* Add this item to the list and increment the position */
PyList_SetItem(list, pos++, item);
/* Advance to the next entry */
zend_hash_move_forward(Z_ARRVAL_PP(hash));
}
return list;
}
/* {{{ static zval* array_to_hash */
static zval *array_to_hash(zval *array)
{
zval *hash, **entry;
char *name_lc;
/*
* Well, this just transposes the array, popularly known as flipping it, or
* giving it the finger.
*/
MAKE_STD_ZVAL(hash);
array_init(hash);
for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(array));
zend_hash_get_current_data(Z_ARRVAL_P(array), (void**)&entry) == SUCCESS;
zend_hash_move_forward(Z_ARRVAL_P(array))) {
if (Z_TYPE_PP(entry) == IS_STRING) {
/*
* I hate case-insensitivity. Die, die, die.
*/
name_lc = estrndup(Z_STRVAL_PP(entry), Z_STRLEN_PP(entry));
zend_str_tolower(name_lc, Z_STRLEN_PP(entry));
add_assoc_bool_ex(hash, name_lc, Z_STRLEN_PP(entry)+1, 1);
efree(name_lc);
}
}
return hash;
}
/** {{{ int yaf_application_is_module_name(char *name, int len TSRMLS_DC)
* 判断名称是否是已经注册了的module的名称
*/
int yaf_application_is_module_name(char *name, int len TSRMLS_DC) {
zval *modules, **ppzval;
HashTable *ht;
yaf_application_t *app;
/* 获取类的实例，$app = self::$_app */
app = zend_read_static_property(yaf_application_ce, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_APP), 1 TSRMLS_CC);
if (!app || Z_TYPE_P(app) != IS_OBJECT) {
return 0;
}
/* $modules = $this->_modules */
modules = zend_read_property(yaf_application_ce, app, ZEND_STRL(YAF_APPLICATION_PROPERTY_NAME_MODULES), 1 TSRMLS_CC);
if (!modules || Z_TYPE_P(modules) != IS_ARRAY) {
return 0;
}
/* 检测name是否在$this->_modules数组中，在就返回1，不在返回0 */
ht = Z_ARRVAL_P(modules);
zend_hash_internal_pointer_reset(ht);
while (zend_hash_get_current_data(ht, (void **)&ppzval) == SUCCESS) {
if (Z_TYPE_PP(ppzval) == IS_STRING && Z_STRLEN_PP(ppzval) == len
&& strncasecmp(Z_STRVAL_PP(ppzval), name, len) == 0) {
return 1;
}
zend_hash_move_forward(ht);
}
return 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;
}
void *merge_php_config(apr_pool_t *p, void *base_conf, void *new_conf)
{
php_conf_rec *d = base_conf, *e = new_conf, *n = NULL;
php_dir_entry *pe;
php_dir_entry *data;
char *str;
uint str_len;
ulong num_index;
n = create_php_config(p, "merge_php_config");
zend_hash_copy(&n->config, &e->config, NULL, NULL, sizeof(php_dir_entry));
phpapdebug((stderr, "Merge dir (%p)+(%p)=(%p)\n", base_conf, new_conf, n));
for (zend_hash_internal_pointer_reset(&d->config);
zend_hash_get_current_key_ex(&d->config, &str, &str_len,
&num_index, 0, NULL) == HASH_KEY_IS_STRING;
zend_hash_move_forward(&d->config)) {
pe = NULL;
zend_hash_get_current_data(&d->config, (void **) &data);
if (zend_hash_find(&n->config, str, str_len, (void **) &pe) == SUCCESS) {
if (pe->status >= data->status) continue;
}
zend_hash_update(&n->config, str, str_len, data, sizeof(*data), NULL);
phpapdebug((stderr, "ADDING/OVERWRITING %s (%d vs. %d)\n", str, data->status, pe?pe->status:-1));
}
return n;
}
//平均数
ZEND_METHOD( alinq_class , Average )
{
zend_fcall_info fci;
zend_fcall_info_cache fci_cache;
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); //持久化分配内存
zval *retval_ptr = NULL;
long resulTotal = 0,averagable=0;
float averNum;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "f", &fci, &fci_cache) == FAILURE) {
return;
}
dataSource = zend_read_property(ce, getThis(), "dataSource", sizeof("dataSource")-1, 0 TSRMLS_DC);
while (zend_hash_get_current_data(Z_ARRVAL_P(dataSource), (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(dataSource), &key, &keylen,&idx, 0, NULL);
//重新copy一个zval，防止破坏原数据
tmpcopy = *tmpns;
zval_copy_ctor(tmpcopy);
// INIT_PZVAL(tmpcopy);
walu_call_anony_function(&retval_ptr, NULL, fci, "sz", key, keylen,&tmpcopy);
resulTotal = resulTotal + Z_LVAL_P(retval_ptr);
averagable++;
// php_printf("value: %d\n", Z_LVAL_P(retval_ptr));
zend_hash_move_forward(Z_ARRVAL_P(dataSource));
}
// php_printf("resulTotal: %d\n", resulTotal);
// php_printf("averagable: %d\n", averagable);
if(averagable > 0){
averNum = (float)resulTotal/(float)averagable;
// php_printf("averagable: %f\n", averNum);
RETURN_DOUBLE(averNum);
}
RETURN_DOUBLE(0);
RETURN_ZVAL(reArrVal,1,1);
}
/* {{{ 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, next)
{
cassandra_rows* self = NULL;
if (zend_parse_parameters_none() == FAILURE) {
return;
}
self = (cassandra_rows*) zend_object_store_get_object(getThis() TSRMLS_CC);
zend_hash_move_forward(Z_ARRVAL_P(self->rows));
}
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);
}
//迭代函数
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_ini_activate_config
*/
PHPAPI void php_ini_activate_config(HashTable *source_hash, int modify_type, int stage)
{
zend_string *str;
zval *data;
zend_ulong num_index;
/* Walk through config hash and alter matching ini entries using the values found in the hash */
for (zend_hash_internal_pointer_reset(source_hash);
zend_hash_get_current_key(source_hash, &str, &num_index) == HASH_KEY_IS_STRING;
zend_hash_move_forward(source_hash)
) {
data = zend_hash_get_current_data(source_hash);
zend_alter_ini_entry_ex(str, Z_STR_P(data), modify_type, stage, 0);
}
}
/* {{{ pip_zobject_to_pyobject(zval **obj)
Convert a PHP (Zend) object to a Python object */
PyObject *
pip_zobject_to_pyobject(zval **obj)
{
PyObject *dict, *item, *str;
zval **entry;
char *string_key;
long num_key;
/*
* At this point, we represent a PHP object as a dictionary of
* its properties. In the future, we may provide a true object
* conversion (which is entirely possible, but it's more work
* that I plan on doing right now).
*/
dict = PyDict_New();
/* Start at the beginning of the object properties hash */
zend_hash_internal_pointer_reset(Z_OBJPROP_PP(obj));
/* Iterate over the hash's elements */
while (zend_hash_get_current_data(Z_OBJPROP_PP(obj),
(void **)&entry) == SUCCESS) {
/* Convert the PHP value to its Python equivalent (recursion) */
item = pip_zval_to_pyobject(entry);
switch (zend_hash_get_current_key(Z_OBJPROP_PP(obj),
&string_key, &num_key, 0)) {
case HASH_KEY_IS_STRING:
PyDict_SetItemString(dict, string_key, item);
break;
case HASH_KEY_IS_LONG:
str = PyString_FromFormat("%d", num_key);
PyObject_SetItem(dict, str, item);
Py_DECREF(str);
break;
case HASH_KEY_NON_EXISTANT:
php_error(E_ERROR, "No array key");
break;
}
/* Advance to the next entry */
zend_hash_move_forward(Z_OBJPROP_PP(obj));
}
return dict;
}
void apply_config(void *dummy)
{
php_conf_rec *d = dummy;
char *str;
uint str_len;
php_dir_entry *data;
for (zend_hash_internal_pointer_reset(&d->config);
zend_hash_get_current_key(&d->config, &str, &str_len, NULL) == HASH_KEY_IS_STRING;
zend_hash_move_forward(&d->config)) {
zend_hash_get_current_data(&d->config, (void **) &data);
phpapdebug((stderr, "APPLYING (%s)(%s)\n", str, data->value));
if (zend_alter_ini_entry(str, str_len, data->value, data->value_len, data->status, data->htaccess?PHP_INI_STAGE_HTACCESS:PHP_INI_STAGE_ACTIVATE) == FAILURE) {
phpapdebug((stderr, "..FAILED\n"));
}
}
}
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);
}
/* {{{ pip_hash_to_dict(zval **hash)
Convert a PHP hash to a Python dictionary */
PyObject *
pip_hash_to_dict(zval **hash)
{
PyObject *dict, *item, *integer;
zval **entry;
char *string_key;
long num_key = 0;
/* Make sure we were given a PHP hash */
if (Z_TYPE_PP(hash) != IS_ARRAY) {
return NULL;
}
/* Create a new empty dictionary */
dict = PyDict_New();
/* Let's start at the very beginning, a very good place to start. */
zend_hash_internal_pointer_reset(Z_ARRVAL_PP(hash));
/* Iterate over the hash's elements */
while (zend_hash_get_current_data(Z_ARRVAL_PP(hash),
(void **)&entry) == SUCCESS) {
/* Convert the PHP value to its Python equivalent (recursion) */
item = pip_zval_to_pyobject(entry);
/* Assign the item with the appropriate key type (string or integer) */
switch (zend_hash_get_current_key(Z_ARRVAL_PP(hash), &string_key,
&num_key, 0)) {
case HASH_KEY_IS_STRING:
PyDict_SetItemString(dict, string_key, item);
break;
case HASH_KEY_IS_LONG:
integer = PyInt_FromLong(num_key);
PyDict_SetItem(dict, integer, item);
Py_DECREF(integer);
break;
}
/* Advance to the next entry */
zend_hash_move_forward(Z_ARRVAL_PP(hash));
}
return dict;
}
//数组覆盖
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);
}
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;
}
static char *_readline_command_generator(const char *text, int state)
{
HashTable *myht = Z_ARRVAL(_readline_array);
zval **entry;
if (!state) {
zend_hash_internal_pointer_reset(myht);
}
while (zend_hash_get_current_data(myht, (void **)&entry) == SUCCESS) {
zend_hash_move_forward(myht);
convert_to_string_ex(entry);
if (strncmp (Z_STRVAL_PP(entry), text, strlen(text)) == 0) {
return (strdup(Z_STRVAL_PP(entry)));
}
}
return NULL;
}
static void php_print_gpcse_array(char *name, uint name_length ELS_DC)
{
zval **data, **tmp, tmp2;
char *string_key;
ulong num_key;
if (zend_hash_find(&EG(symbol_table), name, name_length+1, (void **) &data)!=FAILURE
&& ((*data)->type==IS_ARRAY)) {
zend_hash_internal_pointer_reset((*data)->value.ht);
while (zend_hash_get_current_data((*data)->value.ht, (void **) &tmp) == SUCCESS) {
PUTS("<TR VALIGN=\"baseline\" BGCOLOR=\"" PHP_CONTENTS_COLOR "\">");
PUTS("<TD BGCOLOR=\"" PHP_ENTRY_NAME_COLOR "\"><B>");
PUTS(name);
PUTS("[\"");
switch (zend_hash_get_current_key((*data)->value.ht, &string_key, &num_key, 0)) {
case HASH_KEY_IS_STRING:
zend_html_puts(string_key, strlen(string_key));
break;
case HASH_KEY_IS_LONG:
php_printf("%ld",num_key);
break;
}
PUTS("\"]</B></TD><TD>");
if ((*tmp)->type == IS_ARRAY) {
PUTS("<PRE>");
zend_print_zval_r(*tmp, 0);
PUTS("</PRE>");
} else if ((*tmp)->type != IS_STRING) {
tmp2 = **tmp;
zval_copy_ctor(&tmp2);
convert_to_string(&tmp2);
zend_html_puts(tmp2.value.str.val, tmp2.value.str.len);
zval_dtor(&tmp2);
} else {
zend_html_puts((*tmp)->value.str.val, (*tmp)->value.str.len);
}
PUTS(" </TD></TR>\n");
zend_hash_move_forward((*data)->value.ht);
}
}
}
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;
}
/* {{{ xslt_make_array()
Make an XSLT array (char **) from a zval array (HashTable *) */
extern void xslt_make_array(zval **zarr, char ***carr)
{
zval **current;
HashTable *arr;
int idx = 0;
arr = HASH_OF(*zarr);
if (! arr) {
php_error(E_WARNING, "Invalid argument or parameter array to %s",
get_active_function_name());
return;
}
*carr = emalloc((zend_hash_num_elements(arr) * 2) + 1);
for (zend_hash_internal_pointer_reset(arr);
zend_hash_get_current_data(arr, (void **) ¤t) == SUCCESS;
zend_hash_move_forward(arr)) {
char *string_key = NULL;
ulong num_key;
int type;
SEPARATE_ZVAL(current);
convert_to_string_ex(current);
type = zend_hash_get_current_key(arr, &string_key, &num_key, 0);
if (type == HASH_KEY_IS_LONG) {
php_error(E_WARNING, "Invalid argument or parameter array to %s",
get_active_function_name());
return;
}
(*carr)[idx++] = estrdup(string_key);
(*carr)[idx++] = estrndup(Z_STRVAL_PP(current), Z_STRLEN_PP(current));
}
(*carr)[idx] = NULL;
}
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;
}
