#include "devs_internal.h"

#include <math.h>

bool devs_is_string(devs_ctx_t *ctx, value_t v) {

unsigned tag;

switch (devs_handle_type(v)) {

case DEVS_HANDLE_TYPE_GC_OBJECT:

tag = devs_gc_tag(devs_handle_ptr_value(ctx, v));

return tag == DEVS_GC_TAG_STRING || tag == DEVS_GC_TAG_STRING_JMP;

case DEVS_HANDLE_TYPE_IMG_BUFFERISH:

return !devs_bufferish_is_buffer(v);

default:

return false;

}

}

bool devs_is_number(value_t v) {

return devs_is_tagged_int(v) || devs_handle_type(v) == DEVS_HANDLE_TYPE_FLOAT64;

}

const devs_utf8_string_t *devs_string_get_utf8_struct(devs_ctx_t *ctx, value_t v) {

switch (devs_handle_type(v)) {

case DEVS_HANDLE_TYPE_GC_OBJECT: {

void *ptr = devs_handle_ptr_value(ctx, v);

if (devs_gc_tag(ptr) == DEVS_GC_TAG_STRING_JMP) {

devs_string_jmp_t *s = ptr;

return &s->inner;

}

return NULL;

}

case DEVS_HANDLE_TYPE_IMG_BUFFERISH: {

unsigned idx = devs_handle_value(v);

unsigned tp = (uint16_t)idx >> DEVS_STRIDX__SHIFT;

idx &= (1 << DEVS_STRIDX__SHIFT) - 1;

if (tp == DEVS_STRIDX_UTF8)

return devs_img_get_string_jmp(ctx->img, idx);

return NULL;

}

default:

return NULL;

}

}

const char *devs_string_get_utf8(devs_ctx_t *ctx, value_t v, unsigned *size) {

switch (devs_handle_type(v)) {

case DEVS_HANDLE_TYPE_GC_OBJECT: {

void *ptr = devs_handle_ptr_value(ctx, v);

if (devs_gc_tag(ptr) == DEVS_GC_TAG_STRING) {

devs_string_t *s = ptr;

if (size)

*size = s->length;

return s->data;

} else if (devs_gc_tag(ptr) == DEVS_GC_TAG_STRING_JMP) {

devs_string_jmp_t *s = ptr;

if (size)

*size = s->inner.size;

return devs_utf8_string_data(&s->inner);

}

return NULL;

}

case DEVS_HANDLE_TYPE_IMG_BUFFERISH:

return devs_bufferish_is_buffer(v) ? NULL

: devs_get_static_utf8(ctx, devs_handle_value(v), size);

default:

return NULL;

}

}

value_t devs_builtin_string(unsigned idx) {

return devs_value_from_handle(DEVS_HANDLE_TYPE_IMG_BUFFERISH,

(DEVS_STRIDX_BUILTIN << DEVS_STRIDX__SHIFT) | idx);

}

value_t devs_string_vsprintf(devs_ctx_t *ctx, const char *format, va_list ap) {

if (strstr(format, "%-s"))

JD_PANIC();

va_list ap2;

va_copy(ap2, ap);

unsigned len;

int sz = jd_vsprintf_ext(NULL, 0, format, &len, ap);

// len includes final NUL; devs_string_try_alloc() allocates the final NUL, but doesn't count it

// in its len

len--;

sz--;

value_t r;

char *d = devs_string_prep(ctx, &r, sz, len);

if (d) {

sz = jd_vsprintf_ext(d, sz + 1, format, &len, ap2);

len--;

sz--;

devs_string_finish(ctx, &r, sz, len);

}

return r;

}

value_t devs_string_sprintf(devs_ctx_t *ctx, const char *format, ...) {

va_list arg;

va_start(arg, format);

value_t r = devs_string_vsprintf(ctx, format, arg);

va_end(arg);

return r;

}

value_t devs_string_from_utf8(devs_ctx_t *ctx, const uint8_t *utf8, unsigned size) {

devs_any_string_t *s = devs_string_try_alloc_init(ctx, (const char *)utf8, size);

if (s == NULL) {

return devs_undefined;

} else {

return devs_value_from_gc_obj(ctx, s);

}

}

static value_t buffer_to_string(devs_ctx_t *ctx, value_t v) {

unsigned sz;

const void *data = devs_bufferish_data(ctx, v, &sz);

JD_ASSERT(data != NULL);

unsigned maxbuf = 32;

if (sz > maxbuf) {

return devs_string_sprintf(ctx, "[Buffer[%u] %*p...]", sz, maxbuf, data);

} else {

return devs_string_sprintf(ctx, "[Buffer[%u] %*p]", sz, sz, data);

}

}

value_t devs_value_to_string(devs_ctx_t *ctx, value_t v) {

if (devs_is_string(ctx, v))

return v;

uint32_t hv;

switch (devs_handle_type(v)) {

case DEVS_HANDLE_TYPE_FLOAT64: {

char buf[64];

jd_print_double(buf, devs_value_to_double(ctx, v), 7);

return devs_string_sprintf(ctx, "%s", buf);

}

case DEVS_HANDLE_TYPE_SPECIAL:

switch ((hv = devs_handle_value(v))) {

case DEVS_SPECIAL_NULL:

return devs_builtin_string(DEVS_BUILTIN_STRING_NULL);

case DEVS_SPECIAL_UNDEFINED:

return devs_builtin_string(DEVS_BUILTIN_STRING_UNDEFINED);

case DEVS_SPECIAL_FALSE:

return devs_builtin_string(DEVS_BUILTIN_STRING_FALSE);

case DEVS_SPECIAL_TRUE:

return devs_builtin_string(DEVS_BUILTIN_STRING_TRUE);

case DEVS_SPECIAL_NAN:

return devs_builtin_string(DEVS_BUILTIN_STRING_NAN);

case DEVS_SPECIAL_INF:

return devs_builtin_string(DEVS_BUILTIN_STRING_INFINITY);

case DEVS_SPECIAL_MINF:

return devs_builtin_string(DEVS_BUILTIN_STRING_MINFINITY);

default: {

if (devs_handle_is_builtin(hv))

return devs_string_sprintf(ctx, "[Static Obj: %d]",

(int)hv - DEVS_SPECIAL_BUILTIN_OBJ_FIRST);

else if (devs_handle_is_throw_jmp(hv)) {

return devs_string_sprintf(ctx, "[Throw: %x]", (unsigned)devs_handle_value(v));

} else

JD_PANIC();

}

}

case DEVS_HANDLE_TYPE_FIBER:

return devs_string_sprintf(ctx, "[Fiber: %x]", (unsigned)devs_handle_value(v));

case DEVS_HANDLE_TYPE_STATIC_FUNCTION:

return devs_string_sprintf(ctx, "[Function: %s]",

devs_img_fun_name(ctx->img, devs_handle_value(v)));

case DEVS_HANDLE_TYPE_CLOSURE:

return devs_string_sprintf(ctx, "[Closure: %s]",

devs_img_fun_name(ctx->img, devs_handle_high_value(v)));

case DEVS_HANDLE_TYPE_BOUND_FUNCTION:

case DEVS_HANDLE_TYPE_BOUND_FUNCTION_STATIC:

return devs_string_sprintf(ctx, "[Method: %s]",

devs_img_fun_name(ctx->img, devs_handle_high_value(v)));

case DEVS_HANDLE_TYPE_GC_OBJECT:

switch (devs_gc_tag(devs_handle_ptr_value(ctx, v))) {

case DEVS_GC_TAG_ARRAY:

return devs_builtin_string(DEVS_BUILTIN_STRING_ARRAY); // TODO stringify array?

case DEVS_GC_TAG_BOUND_FUNCTION:

return devs_builtin_string(DEVS_BUILTIN_STRING_FUNCTION); // TODO?

case DEVS_GC_TAG_BUFFER:

return buffer_to_string(ctx, v);

case DEVS_GC_TAG_PACKET: {

devs_packet_t *pkt = devs_handle_ptr_value(ctx, v);

return devs_string_sprintf(ctx, "[Packet: %s cmd=%x sz=%d]",

devs_role_name(ctx, pkt->roleidx), pkt->service_command,

pkt->payload->length);

}

case DEVS_GC_TAG_IMAGE: {

devs_gimage_t *img = devs_handle_ptr_value(ctx, v);

return devs_string_sprintf(ctx, "[Image: %dx%d (%d bpp)]", img->width, img->height,

img->bpp);

}

case DEVS_GC_TAG_SHORT_MAP:

case DEVS_GC_TAG_HALF_STATIC_MAP:

case DEVS_GC_TAG_MAP:

return devs_builtin_string(DEVS_BUILTIN_STRING_MAP);

case DEVS_GC_TAG_BUILTIN_PROTO: // can't happen

case DEVS_GC_TAG_STRING_JMP: // handled on top

case DEVS_GC_TAG_STRING: // handled on top

default:

JD_PANIC();

}

case DEVS_HANDLE_TYPE_IMG_BUFFERISH:

JD_ASSERT(devs_bufferish_is_buffer(v));

return buffer_to_string(ctx, v);

case DEVS_HANDLE_TYPE_ROLE:

return devs_string_sprintf(ctx, "[Role: %s]", devs_role_name(ctx, devs_handle_value(v)));

case DEVS_HANDLE_TYPE_ROLE_MEMBER: {

unsigned roleidx;

const devs_service_spec_t *spec = devs_value_to_service_spec(ctx, v);

if (spec)

return devs_string_sprintf(ctx, "[ServiceSpec: %s]",

devs_img_get_utf8(ctx->img, spec->name_idx, NULL));

const devs_packet_spec_t *pkt = devs_decode_role_packet(ctx, v, &roleidx);

if (roleidx == DEVS_ROLE_INVALID) {

spec = devs_img_get_service_spec(ctx->img, devs_packet_spec_parent(ctx, pkt));

return devs_string_sprintf(ctx, "[PacketSpec: %s.%s]",

devs_img_get_utf8(ctx->img, spec->name_idx, NULL),

devs_img_get_utf8(ctx->img, pkt->name_idx, NULL));

} else

return devs_string_sprintf(ctx, "[Role: %s.%s]", devs_role_name(ctx, roleidx),

devs_img_get_utf8(ctx->img, pkt->name_idx, NULL));

}

default:

JD_PANIC();

}

}

static value_t devs_value_to_string_and_pin(devs_ctx_t *ctx, value_t a) {

if (!devs_is_string(ctx, a)) {

value_t tmp = devs_value_to_string(ctx, a);

devs_value_pin(ctx, tmp);

devs_value_unpin(ctx, a);

return tmp;

} else {

return a;

}

}

void devs_map_set_string_field(devs_ctx_t *ctx, devs_map_t *m, unsigned builtin_str, value_t msg) {

devs_value_pin(ctx, msg);

msg = devs_value_to_string_and_pin(ctx, msg);

devs_map_set(ctx, m, devs_builtin_string(builtin_str), msg);

devs_value_unpin(ctx, msg);

}

value_t devs_string_concat(devs_ctx_t *ctx, value_t a, value_t b) {

bool dup = (a.u64 == b.u64);

devs_value_pin(ctx, a);

if (!dup)

devs_value_pin(ctx, b);

a = devs_value_to_string_and_pin(ctx, a);

if (dup)

b = a;

else

b = devs_value_to_string_and_pin(ctx, b);

const char *ap, *bp;

unsigned asz, bsz, alen, blen;

ap = devs_string_get_utf8(ctx, a, &asz);

bp = devs_string_get_utf8(ctx, b, &bsz);

alen = devs_string_length(ctx, a);

blen = devs_string_length(ctx, b);

value_t r;

if (ap == NULL || bp == NULL) {

// strange...

devs_invalid_program(ctx, 60126);

r = devs_undefined;

} else if (asz == 0) {

r = b;

} else if (bsz == 0) {

r = a;

} else {

unsigned sz = asz + bsz;

unsigned len = alen + blen;

char *p = devs_string_prep(ctx, &r, sz, len);

if (p) {

memcpy(p, ap, asz);

memcpy(p + asz, bp, bsz);

devs_string_finish(ctx, &r, sz, len);

}

}

devs_value_unpin(ctx, a);

if (!dup)

devs_value_unpin(ctx, b);

return r;

}

static int sanitize_idx(int sz, int start) {

if (start < 0) {

start += sz;

if (start < 0)

start = 0;

}

if (start > sz)

start = sz;

return start;

}

value_t devs_string_slice(devs_ctx_t *ctx, value_t str, int start, int endp) {

unsigned sz;

const char *data = devs_string_get_utf8(ctx, str, &sz);

if (!data)

return devs_undefined;

int slen = devs_string_length(ctx, str);

start = sanitize_idx(slen, start);

endp = sanitize_idx(slen, endp);

int len = endp - start;

if (len <= 0)

return devs_builtin_string(DEVS_BUILTIN_STRING__EMPTY);

if (start == 0 && len == slen)

return str;

start = devs_string_index(ctx, str, start);

endp = devs_string_index(ctx, str, endp);

if (start < 0)

start = sz; // shouldn't happen

if (endp < 0)

endp = sz;

devs_any_string_t *r = devs_string_try_alloc_init(ctx, data + start, endp - start);

return devs_value_from_gc_obj(ctx, r);

}