PHP_METHOD(Test_NativeArray, testArray16) {
zval *a;
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(a);
array_init_size(a, 5);
add_assoc_double_ex(a, SS("hello1"), 1.0);
add_assoc_double_ex(a, SS("hello2"), 2.0);
add_assoc_double_ex(a, SS("hello3"), 3.0);
RETURN_CCTOR(a);
}
PHP_METHOD(Test_NativeArray, testArray16) {
zval a;
zval *this_ptr = getThis();
ZVAL_UNDEF(&a);
ZEPHIR_MM_GROW();
ZEPHIR_INIT_VAR(&a);
zephir_create_array(&a, 3, 0 TSRMLS_CC);
add_assoc_double_ex(&a, SL("hello1"), 1.0);
add_assoc_double_ex(&a, SL("hello2"), 2.0);
add_assoc_double_ex(&a, SL("hello3"), 3.0);
RETURN_CCTOR(&a);
}
bool ssdb_geo_get(
SSDBSock *ssdb_sock,
char *key,
int key_len,
char *member_key,
int member_key_len,
INTERNAL_FUNCTION_PARAMETERS) {
double latlong[2] = {0};
if (!ssdb_geo_member(ssdb_sock, key, key_len, member_key, member_key_len, (double *)latlong)) {
return false;
}
array_init(return_value);
add_assoc_double_ex(return_value, ZEND_STRS("latitude"), latlong[0]);
add_assoc_double_ex(return_value, ZEND_STRS("longitude"), latlong[1]);
return true;
}
static void php_swoole_table_row2array(swTable *table, swTableRow *row, zval *return_value)
{
array_init(return_value);
swTableColumn *col = NULL;
swTable_string_length_t vlen = 0;
double dval = 0;
int64_t lval = 0;
char *k;
sw_spinlock(&row->lock);
while(1)
{
col = swHashMap_each(table->columns, &k);
if (col == NULL)
{
break;
}
if (col->type == SW_TABLE_STRING)
{
memcpy(&vlen, row->data + col->index, sizeof(swTable_string_length_t));
sw_add_assoc_stringl_ex(return_value, col->name->str, col->name->length + 1, row->data + col->index + sizeof(swTable_string_length_t), vlen, 1);
}
else if (col->type == SW_TABLE_FLOAT)
{
memcpy(&dval, row->data + col->index, sizeof(dval));
add_assoc_double_ex(return_value, col->name->str, col->name->length + 1, dval);
}
else
{
switch (col->type)
{
case SW_TABLE_INT8:
memcpy(&lval, row->data + col->index, 1);
add_assoc_long_ex(return_value, col->name->str, col->name->length + 1, (int8_t) lval);
break;
case SW_TABLE_INT16:
memcpy(&lval, row->data + col->index, 2);
add_assoc_long_ex(return_value, col->name->str, col->name->length + 1, (int16_t) lval);
break;
case SW_TABLE_INT32:
memcpy(&lval, row->data + col->index, 4);
add_assoc_long_ex(return_value, col->name->str, col->name->length + 1, (int32_t) lval);
break;
default:
memcpy(&lval, row->data + col->index, 8);
add_assoc_long_ex(return_value, col->name->str, col->name->length + 1, lval);
break;
}
}
}
sw_spinlock_release(&row->lock);
}
static void pcntl_sigwaitinfo(INTERNAL_FUNCTION_PARAMETERS, int timedwait) /* {{{ */
{
zval *user_set, **user_signo, *user_siginfo = NULL;
long tv_sec = 0, tv_nsec = 0;
sigset_t set;
HashPosition pos;
int signo;
siginfo_t siginfo;
struct timespec timeout;
if (timedwait) {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|zll", &user_set, &user_siginfo, &tv_sec, &tv_nsec) == FAILURE) {
return;
}
} else {
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|z", &user_set, &user_siginfo) == FAILURE) {
return;
}
}
if (sigemptyset(&set) != 0) {
PCNTL_G(last_error) = errno;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
RETURN_FALSE;
}
zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(user_set), &pos);
while (zend_hash_get_current_data_ex(Z_ARRVAL_P(user_set), (void **)&user_signo, &pos) == SUCCESS)
{
if (Z_TYPE_PP(user_signo) != IS_LONG) {
SEPARATE_ZVAL(user_signo);
convert_to_long_ex(user_signo);
}
signo = Z_LVAL_PP(user_signo);
if (sigaddset(&set, signo) != 0) {
PCNTL_G(last_error) = errno;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
RETURN_FALSE;
}
zend_hash_move_forward_ex(Z_ARRVAL_P(user_set), &pos);
}
if (timedwait) {
timeout.tv_sec = (time_t) tv_sec;
timeout.tv_nsec = tv_nsec;
signo = sigtimedwait(&set, &siginfo, &timeout);
} else {
signo = sigwaitinfo(&set, &siginfo);
}
if (signo == -1 && errno != EAGAIN) {
PCNTL_G(last_error) = errno;
php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", strerror(errno));
}
/*
* sigtimedwait and sigwaitinfo can return 0 on success on some
* platforms, e.g. NetBSD
*/
if (!signo && siginfo.si_signo) {
signo = siginfo.si_signo;
}
if (signo > 0 && user_siginfo) {
if (Z_TYPE_P(user_siginfo) != IS_ARRAY) {
zval_dtor(user_siginfo);
array_init(user_siginfo);
} else {
zend_hash_clean(Z_ARRVAL_P(user_siginfo));
}
add_assoc_long_ex(user_siginfo, "signo", sizeof("signo"), siginfo.si_signo);
add_assoc_long_ex(user_siginfo, "errno", sizeof("errno"), siginfo.si_errno);
add_assoc_long_ex(user_siginfo, "code", sizeof("code"), siginfo.si_code);
switch(signo) {
#ifdef SIGCHLD
case SIGCHLD:
add_assoc_long_ex(user_siginfo, "status", sizeof("status"), siginfo.si_status);
# ifdef si_utime
add_assoc_double_ex(user_siginfo, "utime", sizeof("utime"), siginfo.si_utime);
# endif
# ifdef si_stime
add_assoc_double_ex(user_siginfo, "stime", sizeof("stime"), siginfo.si_stime);
# endif
add_assoc_long_ex(user_siginfo, "pid", sizeof("pid"), siginfo.si_pid);
add_assoc_long_ex(user_siginfo, "uid", sizeof("uid"), siginfo.si_uid);
break;
#endif
case SIGILL:
case SIGFPE:
case SIGSEGV:
case SIGBUS:
add_assoc_double_ex(user_siginfo, "addr", sizeof("addr"), (long)siginfo.si_addr);
break;
#ifdef SIGPOLL
case SIGPOLL:
add_assoc_long_ex(user_siginfo, "band", sizeof("band"), siginfo.si_band);
# ifdef si_fd
add_assoc_long_ex(user_siginfo, "fd", sizeof("fd"), siginfo.si_fd);
# endif
break;
#endif
EMPTY_SWITCH_DEFAULT_CASE();
}
}
RETURN_LONG(signo);
}
PHP_METHOD(Test_Fasta, main) {
int ZEPHIR_LAST_CALL_STATUS;
zval *_0;
zval *n, *alu = NULL, *iub, *homoSap, *_1;
ZEPHIR_MM_GROW();
zephir_fetch_params(1, 1, 0, &n);
ZEPHIR_INIT_VAR(_0);
ZEPHIR_CONCAT_SSSSSSS(_0, "GGCCGGGCGCGGTGGCTCACGCCTGTAATCCCAGCACTTTGG", "GAGGCCGAGGCGGGCGGATCACCTGAGGTCAGGAGTTCGAGA", "CCAGCCTGGCCAACATGGTGAAACCCCGTCTCTACTAAAAAT", "ACAAAAATTAGCCGGGCGTGGTGGCGCGCGCCTGTAATCCCA", "GCTACTCGGGAGGCTGAGGCAGGAGAATCGCTTGAACCCGGG", "AGGCGGAGGTTGCAGTGAGCCGAGATCGCGCCACTGCACTCC", "AGCCTGGGCGACAGAGCGAGACTCCGTCTCAAAAA");
ZEPHIR_CPY_WRT(alu, _0);
ZEPHIR_INIT_VAR(iub);
zephir_create_array(iub, 15, 0 TSRMLS_CC);
add_assoc_double_ex(iub, SS("a"), 0.27);
add_assoc_double_ex(iub, SS("c"), 0.12);
add_assoc_double_ex(iub, SS("g"), 0.12);
add_assoc_double_ex(iub, SS("t"), 0.27);
add_assoc_double_ex(iub, SS("B"), 0.02);
add_assoc_double_ex(iub, SS("D"), 0.02);
add_assoc_double_ex(iub, SS("H"), 0.02);
add_assoc_double_ex(iub, SS("K"), 0.02);
add_assoc_double_ex(iub, SS("M"), 0.02);
add_assoc_double_ex(iub, SS("N"), 0.02);
add_assoc_double_ex(iub, SS("R"), 0.02);
add_assoc_double_ex(iub, SS("S"), 0.02);
add_assoc_double_ex(iub, SS("V"), 0.02);
add_assoc_double_ex(iub, SS("W"), 0.02);
add_assoc_double_ex(iub, SS("Y"), 0.02);
ZEPHIR_INIT_VAR(homoSap);
zephir_create_array(homoSap, 4, 0 TSRMLS_CC);
add_assoc_double_ex(homoSap, SS("a"), 0.3029549426680);
add_assoc_double_ex(homoSap, SS("c"), 0.1979883004921);
add_assoc_double_ex(homoSap, SS("g"), 0.1975473066391);
add_assoc_double_ex(homoSap, SS("t"), 0.3015094502008);
php_printf("%s", ">ONE H**o sapiens alu");
ZEPHIR_INIT_VAR(_1);
ZVAL_LONG(_1, (2 * zephir_get_numberval(n)));
ZEPHIR_CALL_METHOD(NULL, this_ptr, "fastarepeat", NULL, 0, _1, alu);
zephir_check_call_status();
ZEPHIR_MM_RESTORE();
}
bool ssdb_geo_neighbours(
SSDBSock *ssdb_sock, char *key,
int key_len,
char *member_key,
int member_key_len,
double radius_meters,
long return_limit,
long offset_limit,
long zscan_limit,
INTERNAL_FUNCTION_PARAMETERS) {
double latlong[2] = {0};
if (!ssdb_geo_member(ssdb_sock, key, key_len, member_key, member_key_len, (double *)latlong)) {
return false;
}
SSDBGeoObj *ssdb_geo_obj = emalloc(sizeof(SSDBGeoObj));
ssdb_geo_obj->ssdb_sock = ssdb_sock;
ssdb_geo_obj->key = key;
ssdb_geo_obj->key_len = key_len;
ssdb_geo_obj->member_key = member_key;
ssdb_geo_obj->member_key_len = member_key_len;
ssdb_geo_obj->limit_str = NULL;
ssdb_geo_obj->limit_str_len = spprintf(&ssdb_geo_obj->limit_str, 0, "%ld", zscan_limit);
GeoHashRadius georadius = geohashGetAreasByRadiusWGS84(latlong[0], latlong[1], radius_meters);
SSDBGeoList *l = ssdb_geo_members(ssdb_geo_obj, georadius, latlong[0], latlong[1], radius_meters);
efree(ssdb_geo_obj->limit_str);
efree(ssdb_geo_obj);
if (l == NULL) {
return false;
}
return_limit = return_limit <= 0 ? l->num : return_limit;
int i = 0;
SSDBGeoPoint *p_l = malloc(sizeof(SSDBGeoPoint) * l->num);
SSDBGeoPoint *p;
SSDBGeoNode *n = l->head;
while (n != NULL) {
p = (SSDBGeoPoint *)n->data;
p_l[i].member = p->member;
p_l[i].latitude = p->latitude;
p_l[i].longitude = p->longitude;
p_l[i].dist = p->dist;
n = n->next;
i++;
}
qsort(p_l, l->num, sizeof(SSDBGeoPoint), ssdb_geo_point_sort_asc);
zval *temp;
int return_num = 0;
array_init(return_value);
offset_limit = offset_limit < 0 ? 0 : offset_limit;
for (i = 0; i < l->num; i++) {
if (i >= offset_limit && return_num < return_limit) {
MAKE_STD_ZVAL(temp);
array_init_size(temp, 3);
add_assoc_double_ex(temp, ZEND_STRS("latitude"), p_l[i].latitude);
add_assoc_double_ex(temp, ZEND_STRS("longitude"), p_l[i].longitude);
add_assoc_double_ex(temp, ZEND_STRS("distance"), p_l[i].dist);
add_assoc_zval(return_value, p_l[i].member, temp);
return_num++;
}
efree(p_l[i].member);
}
free(p_l);
ssdb_geo_list_destory(l);
return true;
}
