#include <assert.h>
#include <limits.h>
#include <math.h>
#include <string.h>
#include <stdlib.h>
#include "jv_alloc.h"
#include "jv_private.h"
// making this static verbose function here
// until we introduce a less confusing naming scheme
// of jv_* API with regards to the memory management
static double jv_number_get_value_and_consume(jv number) {
double value = jv_number_value(number);
jv_free(number);
return value;
}
static jv parse_slice(jv j, jv slice, int* pstart, int* pend) {
// Array slices
jv start_jv = jv_object_get(jv_copy(slice), jv_string("start"));
jv end_jv = jv_object_get(slice, jv_string("end"));
if (jv_get_kind(start_jv) == JV_KIND_NULL) {
jv_free(start_jv);
start_jv = jv_number(0);
}
int len;
if (jv_get_kind(j) == JV_KIND_ARRAY) {
len = jv_array_length(j);
} else if (jv_get_kind(j) == JV_KIND_STRING) {
len = jv_string_length_codepoints(j);
} else {
/*
* XXX This should be dead code because callers shouldn't call this
* function if `j' is neither an array nor a string.
*/
jv_free(j);
jv_free(start_jv);
jv_free(end_jv);
return jv_invalid_with_msg(jv_string("Only arrays and strings can be sliced"));
}
if (jv_get_kind(end_jv) == JV_KIND_NULL) {
jv_free(end_jv);
end_jv = jv_number(len);
}
if (jv_get_kind(start_jv) != JV_KIND_NUMBER ||
jv_get_kind(end_jv) != JV_KIND_NUMBER) {
jv_free(start_jv);
jv_free(end_jv);
return jv_invalid_with_msg(jv_string("Array/string slice indices must be integers"));
}
double dstart = jv_number_value(start_jv);
double dend = jv_number_value(end_jv);
int start, end;
jv_free(start_jv);
jv_free(end_jv);
if (isnan(dstart)) dstart = 0;
if (dstart < 0) dstart += len;
if (dstart < 0) dstart = 0;
if (dstart > len) dstart = len;
start = dstart > INT_MAX ? INT_MAX : (int)dstart; // Rounds down
if (isnan(dend)) dend = len;
if (dend < 0) dend += len;
if (dend < 0) dend = start;
end = dend > INT_MAX ? INT_MAX : (int)dend;
if (end > len) end = len;
if (end < len) end += end < dend ? 1 : 0; // We round start down
// but round end up
if (end < start) end = start;
assert(0 <= start && start <= end && end <= len);
*pstart = start;
*pend = end;
return jv_true();
}
jv jv_get(jv t, jv k) {
jv v;
if (jv_get_kind(t) == JV_KIND_OBJECT && jv_get_kind(k) == JV_KIND_STRING) {
v = jv_object_get(t, k);
if (!jv_is_valid(v)) {
jv_free(v);
v = jv_null();
}
} else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_NUMBER) {
if (jvp_number_is_nan(k)) {
jv_free(t);
v = jv_null();
} else {
double didx = jv_number_value(k);
if (jvp_number_is_nan(k)) {
v = jv_null();
} else {
if (didx < INT_MIN) didx = INT_MIN;
if (didx > INT_MAX) didx = INT_MAX;
int idx = (int)didx;
if (idx < 0)
idx += jv_array_length(jv_copy(t));
v = jv_array_get(t, idx);
if (!jv_is_valid(v)) {
jv_free(v);
v = jv_null();
}
}
}
jv_free(k);
} else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_OBJECT) {
int start, end;
jv e = parse_slice(jv_copy(t), k, &start, &end);
if (jv_get_kind(e) == JV_KIND_TRUE) {
v = jv_array_slice(t, start, end);
} else {
jv_free(t);
v = e;
}
} else if (jv_get_kind(t) == JV_KIND_STRING && jv_get_kind(k) == JV_KIND_OBJECT) {
int start, end;
jv e = parse_slice(jv_copy(t), k, &start, &end);
if (jv_get_kind(e) == JV_KIND_TRUE) {
v = jv_string_slice(t, start, end);
} else {
jv_free(t);
v = e;
}
} else if (jv_get_kind(t) == JV_KIND_ARRAY && jv_get_kind(k) == JV_KIND_ARRAY) {
v = jv_array_indexes(t