void esp_sj_uart_init(struct v7 *v7) {
sj_us[0].v7 = sj_us[1].v7 = v7;
os_timer_setfn(&sj_us[0].timer, esp_sj_uart_dispatcher, (void *) 0);
os_timer_setfn(&sj_us[1].timer, esp_sj_uart_dispatcher, (void *) 1);
s_uart_proto = v7_mk_object(v7);
v7_set_method(v7, s_uart_proto, "configure", UART_configure);
v7_set_method(v7, s_uart_proto, "onRecv", UART_onRecv);
v7_set_method(v7, s_uart_proto, "recv", UART_recv);
v7_set_method(v7, s_uart_proto, "setRXEnabled", UART_setRXEnabled);
v7_set_method(v7, s_uart_proto, "onTXEmpty", UART_onTXEmpty);
v7_set_method(v7, s_uart_proto, "sendAvail", UART_sendAvail);
v7_set_method(v7, s_uart_proto, "send", UART_send);
v7_set_method(v7, v7_get_global(v7), "UART", UART_get);
sj_us[0].uart_no = 0;
sj_us[0].obj = v7_mk_object(v7);
v7_set_proto(v7, sj_us[0].obj, s_uart_proto);
v7_set(v7, sj_us[0].obj, "_u", ~0, v7_mk_number(0));
v7_own(v7, &sj_us[0].obj);
sj_us[1].uart_no = 1;
sj_us[1].obj = v7_mk_object(v7);
v7_set_proto(v7, sj_us[1].obj, s_uart_proto);
v7_set(v7, sj_us[1].obj, "_u", ~0, v7_mk_number(1));
v7_own(v7, &sj_us[1].obj);
}
void Bot::onJoin(bot_exchange_format& f) {
long l = _onJoin.GetLength();
if (l == 0) return;
v7_val_t user = v7_mk_object(v7);
v7_val_t userName = v7_mk_string(v7, std::string(f[1]).c_str(), ~0, 1);
v7_set(v7, user, "name", ~0, userName);
v7_val_t flags = v7_mk_number((u_long)f[2]);
v7_set(v7, user, "flags", ~0, flags);
v7_val_t age = v7_mk_number((u_char)f[3]);
v7_set(v7, user, "age", ~0, age);
v7_val_t count = v7_mk_number((int)f[4]);
v7_set(v7, user, "count", ~0, count);
v7_val_t gifts = v7_mk_number((u_long)f[5]);
v7_set(v7, user, "gifts", ~0, gifts);
long i;
v7_val_t* func;
v7_val_t args;
for (i = 0; i < l; i++) {
func = (v7_val_t*)_onJoin.GetAt(i);
args = v7_mk_array(v7);
v7_array_push(v7, args, user);
v7_apply(v7, *func, *v7Obj, args, NULL);
}
}
static enum v7_err Sys_prof(struct v7 *v7, v7_val_t *res) {
*res = v7_mk_object(v7);
v7_set(v7, *res, "sysfree", 7, v7_mk_number(sj_get_free_heap_size()));
v7_set(v7, *res, "used_by_js", 10,
v7_mk_number(v7_heap_stat(v7, V7_HEAP_STAT_HEAP_USED)));
v7_set(v7, *res, "used_by_fs", 10, v7_mk_number(sj_get_fs_memory_usage()));
return V7_OK;
}
static void call_sum(struct v7 *v7) {
v7_val_t func, result, args;
func = v7_get(v7, v7_get_global(v7), "sum", 3);
args = v7_mk_array(v7);
v7_array_push(v7, args, v7_mk_number(123.0));
v7_array_push(v7, args, v7_mk_number(456.789));
v7_apply(v7, func, v7_mk_undefined(), args, &result);
printf("Result: %g\n", v7_to_number(result));
}
void Bot::onText(bot_exchange_format& f) {
long i, l;
l = _onTexts.GetLength();
std::string nick = std::string(f[1]);
std::string text = std::string(f[2]);
v7_val_t attr;
if ((u_char)f[3] == 0) {
attr = v7_mk_undefined();
}
else {
attr = v7_mk_object(v7);
v7_val_t size = v7_mk_number((u_char)f[4]);
v7_set(v7, attr, "size", ~0, size);
COLORREF col = (u_long)f[5];
int r = GetRValue(col);
int g = GetGValue(col);
int b = GetBValue(col);
char strCol[8];
sprintf(strCol, "#%02X%02X%02X", r, g, b);
v7_val_t color = v7_mk_string(v7, strCol, ~0, 1);
v7_set(v7, attr, "color", ~0, color);
v7_val_t effects = v7_mk_number((u_long)f[6]);
v7_set(v7, attr, "effects", ~0, effects);
v7_val_t charset = v7_mk_number((u_char)f[7]);
v7_set(v7, attr, "charset", ~0, charset);
v7_val_t pitch = v7_mk_number((u_char)f[8]);
v7_set(v7, attr, "pitch", ~0, pitch);
std::string font = std::string(f[9]);
v7_val_t fontName = v7_mk_string(v7, font.c_str(), ~0, 1);
v7_set(v7, attr, "font", ~0, fontName);
}
v7_val_t nickName = v7_mk_string(v7, nick.c_str(), ~0, 0);
v7_val_t fullText = v7_mk_string(v7, text.c_str(), ~0, 0);
for (i = 0; i < l; i++) {
v7_val_t* func = (v7_val_t*)_onTexts.GetAt(i);
v7_val_t args;
args = v7_mk_array(v7);
v7_array_push(v7, args, nickName);
v7_array_push(v7, args, fullText);
v7_array_push(v7, args, attr);
v7_apply(v7, *func, *v7Obj, args, NULL);
}
}
int main(void) {
enum v7_err rcode = V7_OK;
struct v7 *v7 = v7_create();
v7_val_t ctor_func, proto, eval_result;
proto = v7_mk_object(v7);
ctor_func = v7_mk_function_with_proto(v7, MyThing_ctor, proto);
v7_def(v7, ctor_func, "MY_CONST", ~0,
(V7_DESC_WRITABLE(0) | V7_DESC_CONFIGURABLE(0)), v7_mk_number(123));
v7_set_method(v7, proto, "myMethod", &MyThing_myMethod);
v7_set(v7, v7_get_global(v7), "MyThing", ~0, ctor_func);
rcode = v7_exec(v7,
"\
print('MyThing.MY_CONST = ', MyThing.MY_CONST); \
var t = new MyThing(456); \
print('t.MY_CONST = ', t.MY_CONST); \
print('t.myMethod = ', t.myMethod); \
print('t.myMethod() = ', t.myMethod());",
&eval_result);
if (rcode != V7_OK) {
fprintf(stderr, "exec error: %d\n", (int) rcode);
}
v7_destroy(v7);
return (int) rcode;
}
static enum v7_err jsSetTimeout(struct v7* v7, v7_val_t* res) {
v7_val_t* func = new v7_val_t;
v7_own(v7, func);
*func = v7_arg(v7, 0);
v7_val_t inv = v7_arg(v7, 1);
if (!v7_is_callable(v7, *func)) {
//TODO: catch error if 1st argument not callable code
return V7_OK;
}
if (!v7_is_number(inv)) {
//TODO: catch error if 2nd argument not a number
return V7_OK;
}
double ms = v7_to_number(inv);
long lms = floor(ms);
//v7_apply(v7, func, _activeBot->getV7Obj(), v7_mk_undefined(), NULL);
TIMER* newTimer = new TIMER;
newTimer->pToFunc = func;
newTimer->delay = lms;
newTimer->timeBegin = GetTickCount();
newTimer->id = (long)newTimer;
_activeBot->_timers.Add(newTimer);
double vOut = (double)newTimer->id;
*res = v7_mk_number(vOut);
return V7_OK;
}
static enum v7_err UART_sendAvail(struct v7 *v7, v7_val_t *res) {
struct esp_sj_uart_state *us;
enum v7_err ret = esp_sj_uart_get_state(v7, &us);
if (ret != V7_OK) return ret;
*res = v7_mk_number(esp_uart_tx_buf(us->uart_no)->avail);
return V7_OK;
}
static enum v7_err js_sum(struct v7 *v7, v7_val_t *res) {
double arg0 = v7_to_number(v7_arg(v7, 0));
double arg1 = v7_to_number(v7_arg(v7, 1));
double result = sum(arg0, arg1);
*res = v7_mk_number(result);
return V7_OK;
}
static int notify_js(enum js_update_status us, const char *info) {
#ifndef CS_DISABLE_JS
if (!v7_is_undefined(s_updater_notify_cb)) {
if (info == NULL) {
sj_invoke_cb1(s_v7, s_updater_notify_cb, v7_mk_number(s_v7, us));
} else {
sj_invoke_cb2(s_v7, s_updater_notify_cb, v7_mk_number(s_v7, us),
v7_mk_string(s_v7, info, ~0, 1));
};
return 1;
}
#else
(void) us;
(void) info;
#endif
return 0;
}
static void gpio_intr_handler_proxy(int pin, enum gpio_level level, void *arg) {
struct v7 *v7 = (struct v7 *) arg;
char prop_name[15];
int len;
len = snprintf(prop_name, sizeof(prop_name), "_ih_%d", (int) pin);
v7_val_t cb = v7_get(v7, v7_get_global(v7), prop_name, len);
if (!v7_is_callable(v7, cb)) {
return;
}
/* Forwarding call to common cbs queue */
v7_val_t args = v7_mk_array(v7);
v7_array_push(v7, args, v7_mk_number(v7, pin));
v7_array_push(v7, args, v7_mk_number(v7, level));
sj_invoke_cb2(v7, s_isr_cb_proxy_v, cb, args);
}
static void gpio_intr_handler_proxy(int pin, int level) {
char prop_name[15];
int len;
v7_val_t res, args;
len = snprintf(prop_name, sizeof(prop_name), "_ih_%d", (int) pin);
v7_val_t cb = v7_get(s_v7, v7_get_global(s_v7), prop_name, len);
if (!v7_is_callable(s_v7, cb)) {
return;
}
args = v7_mk_array(s_v7);
v7_array_push(s_v7, args, v7_mk_number(pin));
v7_array_push(s_v7, args, v7_mk_number(level));
if (v7_apply(s_v7, cb, v7_mk_undefined(), args, &res) != V7_OK) {
/* TODO(mkm): make it print stack trace */
fprintf(stderr, "cb threw an exception\n");
}
}
void init_updater_clubby(struct v7 *v7) {
(void) v7;
#ifndef DISABLE_C_CLUBBY
#ifndef CS_DISABLE_JS
s_v7 = v7;
v7_val_t updater = v7_mk_object(v7);
v7_val_t sys = v7_get(v7, v7_get_global(v7), "Sys", ~0);
s_updater_notify_cb = V7_UNDEFINED;
v7_own(v7, &s_updater_notify_cb);
v7_def(v7, sys, "updater", ~0, V7_DESC_ENUMERABLE(0), updater);
v7_set_method(v7, updater, "notify", Updater_notify);
v7_set_method(v7, updater, "start", Updater_startupdate);
v7_def(s_v7, updater, "GOT_REQUEST", ~0,
(V7_DESC_WRITABLE(0) | V7_DESC_CONFIGURABLE(0)),
v7_mk_number(v7, UJS_GOT_REQUEST));
v7_def(s_v7, updater, "COMPLETED", ~0,
(V7_DESC_WRITABLE(0) | V7_DESC_CONFIGURABLE(0)),
v7_mk_number(v7, UJS_COMPLETED));
v7_def(s_v7, updater, "NOTHING_TODO", ~0,
(V7_DESC_WRITABLE(0) | V7_DESC_CONFIGURABLE(0)),
v7_mk_number(v7, UJS_NOTHING_TODO));
v7_def(s_v7, updater, "FAILED", ~0,
(V7_DESC_WRITABLE(0) | V7_DESC_CONFIGURABLE(0)),
v7_mk_number(v7, UJS_ERROR));
#endif
sj_clubby_register_global_command("/v1/SWUpdate.Update", handle_update_req,
NULL);
sj_clubby_register_global_command(clubby_cmd_ready, handle_clubby_ready,
NULL);
#endif
}
void sj_wifi_api_setup(struct v7 *v7) {
v7_val_t s_wifi = v7_mk_object(v7);
v7_own(v7, &s_wifi);
v7_set_method(v7, s_wifi, "setup", sj_Wifi_setup);
v7_set_method(v7, s_wifi, "connect", Wifi_connect);
v7_set_method(v7, s_wifi, "disconnect", Wifi_disconnect);
v7_set_method(v7, s_wifi, "status", Wifi_status);
v7_set_method(v7, s_wifi, "show", Wifi_show);
v7_set_method(v7, s_wifi, "ip", Wifi_ip);
v7_set_method(v7, s_wifi, "changed", Wifi_changed);
v7_set_method(v7, s_wifi, "scan", Wifi_scan);
v7_set_method(v7, s_wifi, "ready", Wifi_ready);
v7_set(v7, v7_get_global(v7), "Wifi", ~0, s_wifi);
v7_set(v7, s_wifi, "CONNECTED", ~0, v7_mk_number(v7, SJ_WIFI_CONNECTED));
v7_set(v7, s_wifi, "DISCONNECTED", ~0,
v7_mk_number(v7, SJ_WIFI_DISCONNECTED));
v7_set(v7, s_wifi, "GOTIP", ~0, v7_mk_number(v7, SJ_WIFI_IP_ACQUIRED));
v7_disown(v7, &s_wifi);
}
V7_PRIVATE
v7_val_t mk_cfunction_obj(struct v7 *v7, v7_cfunction_t *f, int num_args) {
val_t obj = mk_object(v7, v7->vals.function_prototype);
struct gc_tmp_frame tf = new_tmp_frame(v7);
tmp_stack_push(&tf, &obj);
v7_def(v7, obj, "", 0, _V7_DESC_HIDDEN(1), v7_mk_cfunction(f));
if (num_args >= 0) {
v7_def(v7, obj, "length", 6, (V7_DESC_ENUMERABLE(0) | V7_DESC_WRITABLE(0) |
V7_DESC_CONFIGURABLE(0)),
v7_mk_number(v7, num_args));
}
tmp_frame_cleanup(&tf);
return obj;
}
static enum v7_err ADC_readVoltage(struct v7 *v7, v7_val_t *res) {
v7_val_t pinv = v7_arg(v7, 0);
int pin;
if (!v7_is_number(pinv)) {
printf("non-numeric pin\n");
*res = v7_mk_undefined();
} else {
pin = v7_to_number(pinv);
*res = v7_mk_number(sj_adc_read_voltage(pin));
}
return V7_OK;
}
SJ_PRIVATE enum v7_err GPIO_read(struct v7 *v7, v7_val_t *res) {
v7_val_t pinv = v7_arg(v7, 0);
int pin;
if (!v7_is_number(pinv)) {
printf("non-numeric pin\n");
*res = v7_mk_undefined();
} else {
pin = v7_to_number(pinv);
*res = v7_mk_number(sj_gpio_read(pin));
}
return V7_OK;
}
SJ_PRIVATE enum v7_err GPIO_read(struct v7 *v7, v7_val_t *res) {
v7_val_t pinv = v7_arg(v7, 0);
int pin;
if (!v7_is_number(pinv)) {
printf("non-numeric pin\n");
*res = V7_UNDEFINED;
} else {
pin = v7_get_double(v7, pinv);
*res = v7_mk_number(v7, sj_gpio_read(pin));
}
return V7_OK;
}
SJ_PRIVATE enum v7_err sj_set_interval_or_timeout(struct v7 *v7, v7_val_t *res,
int repeat) {
v7_val_t msecsv = v7_arg(v7, 1);
int msecs;
(void) res;
if (!v7_is_callable(v7, v7_arg(v7, 0))) {
printf("cb is not a function\n");
} else if (!v7_is_number(msecsv)) {
printf("msecs is not a number\n");
} else {
v7_val_t cb = v7_arg(v7, 0);
msecs = v7_get_double(v7, msecsv);
*res = v7_mk_number(v7, sj_set_js_timer(msecs, repeat, v7, cb));
}
return V7_OK;
}
void Bot::onTalk(TString& nick, unsigned char flag) {
long l = _onTalk.GetLength();
if (l == 0) return;
long i;
v7_val_t* func;
v7_val_t args;
v7_val_t userName = v7_mk_string(v7, nick.GetAsChar(), ~0, 1);
v7_val_t theFlag = v7_mk_number(flag);
for (i = 0; i < l; i++) {
func = (v7_val_t*)_onTalk.GetAt(i);
args = v7_mk_array(v7);
v7_array_push(v7, args, userName);
v7_array_push(v7, args, theFlag);
v7_apply(v7, *func, *v7Obj, args, NULL);
}
}
static enum v7_err UART_send(struct v7 *v7, v7_val_t *res) {
struct esp_sj_uart_state *us;
enum v7_err ret = esp_sj_uart_get_state(v7, &us);
if (ret != V7_OK) return ret;
v7_val_t arg0 = v7_arg(v7, 0);
if (!v7_is_string(arg0)) {
return v7_throwf(v7, "Error", "String arg required");
}
size_t len = 0;
const char *data = v7_get_string_data(v7, &arg0, &len);
if (data != NULL && len > 0) {
cs_rbuf_t *txb = esp_uart_tx_buf(us->uart_no);
len = MIN(len, txb->avail);
cs_rbuf_append(txb, (uint8_t *) data, len);
esp_sj_uart_schedule_dispatcher(us->uart_no);
}
*res = v7_mk_number(len);
return V7_OK;
}
v7_val_t v7_file_to_val(int fd) {
return v7_mk_number(fd);
}
/* Callback for json_walk() */
static void frozen_cb(void *data, const char *name, size_t name_len,
const char *path, const struct json_token *token) {
struct json_parse_ctx *ctx = (struct json_parse_ctx *) data;
v7_val_t v = V7_UNDEFINED;
(void) path;
v7_own(ctx->v7, &v);
switch (token->type) {
case JSON_TYPE_STRING:
v = v7_mk_string(ctx->v7, token->ptr, token->len, 1 /* copy */);
break;
case JSON_TYPE_NUMBER:
v = v7_mk_number(ctx->v7, cs_strtod(token->ptr, NULL));
break;
case JSON_TYPE_TRUE:
v = v7_mk_boolean(ctx->v7, 1);
break;
case JSON_TYPE_FALSE:
v = v7_mk_boolean(ctx->v7, 0);
break;
case JSON_TYPE_NULL:
v = V7_NULL;
break;
case JSON_TYPE_OBJECT_START:
v = v7_mk_object(ctx->v7);
break;
case JSON_TYPE_ARRAY_START:
v = v7_mk_array(ctx->v7);
break;
case JSON_TYPE_OBJECT_END:
case JSON_TYPE_ARRAY_END: {
/* Object or array has finished: deallocate its frame */
ctx->frame = free_json_frame(ctx, ctx->frame);
} break;
default:
LOG(LL_ERROR, ("Wrong token type %d\n", token->type));
break;
}
if (!v7_is_undefined(v)) {
if (name != NULL && name_len != 0) {
/* Need to define a property on the current object/array */
if (v7_is_object(ctx->frame->val)) {
v7_set(ctx->v7, ctx->frame->val, name, name_len, v);
} else if (v7_is_array(ctx->v7, ctx->frame->val)) {
/*
* TODO(dfrank): consult name_len. Currently it's not a problem due to
* the implementation details of frozen, but it might change
*/
int idx = (int) cs_strtod(name, NULL);
v7_array_set(ctx->v7, ctx->frame->val, idx, v);
} else {
LOG(LL_ERROR, ("Current value is neither object nor array\n"));
}
} else {
/* This is a root value */
assert(ctx->frame == NULL);
/*
* This value will also be the overall result of JSON parsing
* (it's already owned by the `v7_alt_json_parse()`)
*/
ctx->result = v;
}
if (token->type == JSON_TYPE_OBJECT_START ||
token->type == JSON_TYPE_ARRAY_START) {
/* New object or array has just started, so we need to allocate a frame
* for it */
struct json_parse_frame *new_frame = alloc_json_frame(ctx, v);
new_frame->up = ctx->frame;
ctx->frame = new_frame;
}
}
v7_disown(ctx->v7, &v);
}
SJ_PRIVATE enum v7_err Sys_fs_getFreeSpace(struct v7 *v7, v7_val_t *res) {
*res = v7_mk_number(v7, sj_get_storage_free_space());
return V7_OK;
}
static enum v7_err Sys_time(struct v7 *v7, v7_val_t *res) {
(void) v7;
*res = v7_mk_number(v7, cs_time());
return V7_OK;
}
void sj_gpio_api_setup(struct v7 *v7) {
v7_val_t gpio = v7_mk_object(v7);
v7_set(v7, v7_get_global(v7), "GPIO", ~0, gpio);
v7_set_method(v7, gpio, "setMode", GPIO_setMode);
v7_set_method(v7, gpio, "read", GPIO_read);
v7_set_method(v7, gpio, "write", GPIO_write);
v7_set_method(v7, gpio, "setISR", GPIO_setISR);
v7_set(v7, gpio, "INOUT", ~0, v7_mk_number(v7, GPIO_MODE_INOUT));
v7_set(v7, gpio, "IN", ~0, v7_mk_number(v7, GPIO_MODE_INPUT));
v7_set(v7, gpio, "OUT", ~0, v7_mk_number(v7, GPIO_MODE_OUTPUT));
v7_set(v7, gpio, "FLOAT", ~0, v7_mk_number(v7, GPIO_PULL_FLOAT));
v7_set(v7, gpio, "PULLUP", ~0, v7_mk_number(v7, GPIO_PULL_PULLUP));
v7_set(v7, gpio, "PULLDOWN", ~0, v7_mk_number(v7, GPIO_PULL_PULLDOWN));
v7_set(v7, gpio, "OFF", ~0, v7_mk_number(v7, GPIO_INTR_OFF));
v7_set(v7, gpio, "POSEDGE", ~0, v7_mk_number(v7, GPIO_INTR_POSEDGE));
v7_set(v7, gpio, "NEGEDGE", ~0, v7_mk_number(v7, GPIO_INTR_NEGEDGE));
v7_set(v7, gpio, "ANYEDGE", ~0, v7_mk_number(v7, GPIO_INTR_ANYEDGE));
v7_set(v7, gpio, "LOLEVEL", ~0, v7_mk_number(v7, GPIO_INTR_LOLEVEL));
v7_set(v7, gpio, "HILEVEL", ~0, v7_mk_number(v7, GPIO_INTR_HILEVEL));
/*
* TODO(mkm): figure out what to do with this "esp specific" mode.
* It's not really ESP specific, but the soft debouncer is currently
* implemented in esp8266 platform code.
*/
v7_set(v7, gpio, "CLICK", ~0,
v7_mk_number(v7, 6 /* GPIO_INTR_TYPE_ONCLICK */));
if (v7_exec_file(v7, "gpio.js", NULL) != V7_OK) {
/* TODO(mkm): make setup functions return an error code */
abort();
}
}
/*
* Parse URL; used for:
*
* - `URL.parse()`
* - `Http.request()` and `Http.get()`, when provided `opts` is a string.
*/
static enum v7_err sj_url_parse(struct v7 *v7, v7_val_t url_v, v7_val_t *res) {
enum v7_err rcode = V7_OK;
v7_val_t opts, protocol_v;
size_t i, j, len;
int state = 0;
const char *url;
if (!v7_is_string(url_v)) {
rcode = v7_throwf(v7, "TypeError", "URL must be a string");
goto clean;
}
url = v7_get_string_data(v7, &url_v, &len);
opts = v7_mk_object(v7);
for (i = j = 0; j < len; j++) {
switch (state) {
case 0:
if (url[j] == '/') {
protocol_v = v7_mk_string(v7, url + i, j - i - 1, 1);
v7_set(v7, opts, "protocol", ~0, protocol_v);
j += 1;
i = j + 1;
state = 1;
}
break;
case 1:
if (url[j] == '/' || (j > i && url[j] == ':') || j == len - 1) {
int hl = j - i;
if (j == len - 1 && url[j] != '/' && url[j] != ':') hl++;
v7_set(v7, opts, "hostname", ~0, v7_mk_string(v7, url + i, hl, 1));
if (url[j] == '/' || j == len - 1) {
const char *protocol = v7_to_cstring(v7, &protocol_v);
int port = strcasecmp(protocol, "https") == 0 ? 443 : 80;
v7_set(v7, opts, "port", ~0, v7_mk_number(port));
i = j;
if (j == len - 1) j--;
state = 3;
} else {
i = j + 1;
state = 2;
}
}
break;
case 2:
if (url[j] == '/' || j == len - 1) {
char ps[6];
size_t l = j - i;
if (j == len - 1) l++;
if (l > sizeof(ps) - 1) l = sizeof(ps) - 1;
memcpy(ps, url + i, l);
ps[l] = '\0';
v7_set(v7, opts, "port", ~0, v7_mk_number(atoi(ps)));
i = j;
if (j == len - 1) j--;
state = 3;
}
break;
case 3:
if (j == len - 1) {
v7_val_t path_v = j - i > 0 ? v7_mk_string(v7, url + i, j - i + 1, 1)
: v7_mk_string(v7, "/", 1, 1);
v7_set(v7, opts, "path", ~0, path_v);
}
break;
}
}
*res = opts;
clean:
return rcode;
}
/*
* Returns an object describing the free memory.
*
* sysfree: free system heap bytes
* jssize: size of JS heap in bytes
* jsfree: free JS heap bytes
* strres: size of reserved string heap in bytes
* struse: portion of string heap with used data
* objnfree: number of free object slots in js heap
* propnfree: number of free property slots in js heap
* funcnfree: number of free function slots in js heap
*/
SJ_PRIVATE enum v7_err GC_stat(struct v7 *v7, v7_val_t *res) {
/* take a snapshot of the stats that would change as we populate the result */
size_t sysfree = sj_get_free_heap_size();
size_t jssize = v7_heap_stat(v7, V7_HEAP_STAT_HEAP_SIZE);
size_t jsfree = jssize - v7_heap_stat(v7, V7_HEAP_STAT_HEAP_USED);
size_t strres = v7_heap_stat(v7, V7_HEAP_STAT_STRING_HEAP_RESERVED);
size_t struse = v7_heap_stat(v7, V7_HEAP_STAT_STRING_HEAP_USED);
size_t objfree = v7_heap_stat(v7, V7_HEAP_STAT_OBJ_HEAP_FREE);
size_t propnfree = v7_heap_stat(v7, V7_HEAP_STAT_PROP_HEAP_FREE);
*res = v7_mk_object(v7);
v7_set(v7, *res, "sysfree", ~0, v7_mk_number(sysfree));
v7_set(v7, *res, "jssize", ~0, v7_mk_number(jssize));
v7_set(v7, *res, "jsfree", ~0, v7_mk_number(jsfree));
v7_set(v7, *res, "strres", ~0, v7_mk_number(strres));
v7_set(v7, *res, "struse", ~0, v7_mk_number(struse));
v7_set(v7, *res, "objfree", ~0, v7_mk_number(objfree));
v7_set(v7, *res, "objncell", ~0,
v7_mk_number(v7_heap_stat(v7, V7_HEAP_STAT_OBJ_HEAP_CELL_SIZE)));
v7_set(v7, *res, "propnfree", ~0, v7_mk_number(propnfree));
v7_set(v7, *res, "propncell", ~0,
v7_mk_number(v7_heap_stat(v7, V7_HEAP_STAT_PROP_HEAP_CELL_SIZE)));
v7_set(v7, *res, "funcnfree", ~0,
v7_mk_number(v7_heap_stat(v7, V7_HEAP_STAT_FUNC_HEAP_FREE)));
v7_set(v7, *res, "funcncell", ~0,
v7_mk_number(v7_heap_stat(v7, V7_HEAP_STAT_FUNC_HEAP_CELL_SIZE)));
v7_set(v7, *res, "astsize", ~0,
v7_mk_number(v7_heap_stat(v7, V7_HEAP_STAT_FUNC_AST_SIZE)));
v7_set(v7, *res, "owned", ~0,
v7_mk_number(v7_heap_stat(v7, V7_HEAP_STAT_FUNC_OWNED)));
v7_set(v7, *res, "owned_max", ~0,
v7_mk_number(v7_heap_stat(v7, V7_HEAP_STAT_FUNC_OWNED_MAX)));
return V7_OK;
}
void sj_wifi_on_change_js(enum sj_wifi_status event, void *arg) {
struct wifi_cb_arg *cba = (struct wifi_cb_arg *) arg;
if (v7_is_callable(cba->v7, cba->v)) {
sj_invoke_cb1(cba->v7, cba->v, v7_mk_number(cba->v7, event));
}
}