static int symbol_to_string(vm_thread_t *thread, obj_t *sym)
{
SAFE_ASSERT(IS_SYMBOL(*sym));
char *str = SYMBOL(*sym);
RETURN_OBJ(_string(&thread->heap.allocator, str, 0));
}
SKYRAY_METHOD(deferred, promise)
{
if (zend_parse_parameters_none() == FAILURE) {
return;
}
skyray_deferred_t *intern = skyray_deferred_from_obj(Z_OBJ_P(getThis()));
if (!intern->promise) {
intern->promise = skyray_deferred_create_promise();
}
GC_REFCOUNT(intern->promise) ++;
RETURN_OBJ(intern->promise);
}
static int string_set(vm_thread_t *thread, obj_t *ostr,
obj_t *opos, obj_t *oval)
{
SAFE_ASSERT(IS_STRING(*ostr));
SAFE_ASSERT(IS_FIXNUM(*opos));
SAFE_ASSERT(IS_CHAR(*oval));
string_t *str = PTR(*ostr);
int pos = FIXNUM(*opos);
SAFE_ASSERT((pos >= 0) && (pos < str->size-1));
str->str[pos] = CHAR(*oval);
RETURN_OBJ(cvoid);
}
static int string_copy(vm_thread_t *thread, obj_t *osrc)
{
#define STRING_SIZE(o) ((string_t*)PTR(o))->size
SAFE_ASSERT(IS_STRING(*osrc));
int size = STRING_SIZE(*osrc);
void *mem = heap_alloc(&thread->heap, size+sizeof(string_t), t_string);
string_t *str = mem;
str->str = mem+sizeof(string_t);
str->size = size;
str->allocated = 1;
memcpy(str->str, CSTRING(*osrc), size);
RETURN_OBJ(MAKE_HEAP_PTR(str));
}
static int string_copy_to(vm_thread_t *thread, obj_t *odest, obj_t *opos, obj_t *osrc)
{
SAFE_ASSERT(IS_STRING(*odest));
SAFE_ASSERT(IS_HEAP_PTR(*odest));
SAFE_ASSERT(IS_STRING(*osrc));
SAFE_ASSERT(IS_FIXNUM(*opos));
string_t *src = PTR(*osrc);
string_t *dst = PTR(*odest);
SAFE_ASSERT(dst->allocated);
int pos = FIXNUM(*opos);
SAFE_ASSERT((pos >= 0)
&& (pos+src->size <= dst->size));
memcpy(&dst->str[pos], src->str, src->size-1);
RETURN_OBJ(cvoid);
}
static int make_string(vm_thread_t *thread, obj_t *olen, obj_t *ofill)
{
SAFE_ASSERT(IS_FIXNUM(*olen));
SAFE_ASSERT(IS_CHAR(*ofill));
size_t len = FIXNUM(*olen);
void *mem = heap_alloc(&thread->heap, sizeof(string_t)+len+1, t_string);
string_t *str = mem;
str->str = mem+sizeof(string_t);
str->size = len+1;
str->allocated = 1;
char fill = CHAR(*ofill);
int i;
for (i = 0; i < len; i++)
str->str[i] = fill;
str->str[len] = '\0';
RETURN_OBJ(MAKE_HEAP_PTR(str));
}
static int string_concat(vm_thread_t *thread, obj_t *oa, obj_t *ob)
{
SAFE_ASSERT(IS_STRING(*oa));
SAFE_ASSERT(IS_STRING(*ob));
//FIXME: it's not gc safe
string_t *a = PTR(*oa);
string_t *b = PTR(*ob);
size_t new_size = a->size + b->size - 1;
void *mem = heap_alloc(&thread->heap, new_size+sizeof(string_t), t_string);
string_t *new_str = mem;
new_str->str = mem + sizeof(string_t);
new_str->size = new_size;
int sep = a->size-1;
memcpy(new_str->str, a->str, sep);
memcpy(new_str->str+sep, b->str, b->size);
RETURN_OBJ(MAKE_HEAP_PTR(new_str));
}
void stream_client_do_connect_blocking(
skyray_stream_client_t *self, zend_object *protocol_obj,
zend_string *host, zend_long port, zval *return_value)
{
int fd = stream_client_do_connect(host->val, port);
if (fd < 0) {
return;
}
zval zstream;
object_init_ex(&zstream, skyray_ce_Stream);
zend_object *stream = Z_OBJ_P(&zstream);
skyray_stream_t * stream_intern = skyray_stream_from_obj(stream);
skyray_stream_init_blocking(stream_intern, SR_TCP, fd, protocol_obj);
skyray_stream_on_opened(stream_intern, SR_READABLE | SR_WRITABLE);
if (!self->protocol_creator) {
ZVAL_COPY(return_value, &zstream);
return;
}
zend_string *buffer;
++GC_REFCOUNT(protocol_obj); //preventing protocol instance be free'd after connection closed.
while((buffer = skyray_stream_read(stream_intern, 0))) {
if (buffer->len == 0) {
zend_string_free(buffer);
break;
}
skyray_stream_on_data(stream_intern, buffer);
zend_string_free(buffer);
}
RETURN_OBJ(protocol_obj);
}
static int substring(vm_thread_t *thread, obj_t *ostr, obj_t *ostart, obj_t *oend)
{
SAFE_ASSERT(IS_STRING(*ostr));
SAFE_ASSERT(IS_FIXNUM(*ostart));
SAFE_ASSERT(IS_FIXNUM(*oend));
int start = FIXNUM(*ostart);
int end = FIXNUM(*oend);
string_t *str = PTR(*ostr);
SAFE_ASSERT((start >= 0)
&& (start <= end)
&& (end < str->size));
size_t nsize = end-start;
void *mem = heap_alloc(&thread->heap, nsize+sizeof(string_t), t_string);
string_t *dstr = mem;
dstr->str = mem+sizeof(string_t);
dstr->allocated = 1;
dstr->size = nsize+1;
memcpy(dstr->str, &CSTRING(*ostr)[start], nsize);
RETURN_OBJ(MAKE_HEAP_PTR(dstr));
}
