kopia lustrzana https://github.com/micropython/micropython
331 wiersze
12 KiB
C
331 wiersze
12 KiB
C
![]() |
/*
|
||
|
* This file is part of the MicroPython project, http://micropython.org/
|
||
|
*
|
||
|
* The MIT License (MIT)
|
||
|
*
|
||
|
* Copyright (c) 2023-2024 Damien P. George
|
||
|
*
|
||
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
||
|
* of this software and associated documentation files (the "Software"), to deal
|
||
|
* in the Software without restriction, including without limitation the rights
|
||
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
||
|
* copies of the Software, and to permit persons to whom the Software is
|
||
|
* furnished to do so, subject to the following conditions:
|
||
|
*
|
||
|
* The above copyright notice and this permission notice shall be included in
|
||
|
* all copies or substantial portions of the Software.
|
||
|
*
|
||
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
||
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
||
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
||
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
||
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
||
|
* THE SOFTWARE.
|
||
|
*/
|
||
|
|
||
|
#include <stdio.h>
|
||
|
#include <stdlib.h>
|
||
|
|
||
|
#include "emscripten.h"
|
||
|
#include "py/objmodule.h"
|
||
|
#include "py/runtime.h"
|
||
|
#include "proxy_c.h"
|
||
|
|
||
|
// *FORMAT-OFF*
|
||
|
EM_JS(bool, lookup_attr, (int jsref, const char *str, uint32_t * out), {
|
||
|
const base = proxy_js_ref[jsref];
|
||
|
const attr = UTF8ToString(str);
|
||
|
if (attr in base) {
|
||
|
let value = base[attr];
|
||
|
if (typeof value == "function") {
|
||
|
if (base !== globalThis) {
|
||
|
value = value.bind(base);
|
||
|
}
|
||
|
}
|
||
|
proxy_convert_js_to_mp_obj_jsside(value, out);
|
||
|
return true;
|
||
|
} else {
|
||
|
return false;
|
||
|
}
|
||
|
});
|
||
|
// *FORMAT-ON*
|
||
|
|
||
|
EM_JS(void, store_attr, (int jsref, const char *attr_ptr, uint32_t * value_ref), {
|
||
|
const attr = UTF8ToString(attr_ptr);
|
||
|
const value = proxy_convert_mp_to_js_obj_jsside(value_ref);
|
||
|
proxy_js_ref[jsref][attr] = value;
|
||
|
});
|
||
|
|
||
|
EM_JS(void, call0, (int f_ref, uint32_t * out), {
|
||
|
// Because of JavaScript "this" semantics, we must extract the target function
|
||
|
// to a variable before calling it, so "this" is bound to the correct value.
|
||
|
//
|
||
|
// In detail:
|
||
|
// In JavaScript, proxy_js_ref[f_ref] acts like a function call
|
||
|
// proxy_js_ref.at(f_ref), and "this" will be bound to proxy_js_ref if
|
||
|
// there is a chain of calls, such as proxy_js_ref.at(f_ref)().
|
||
|
// But proxy_js_ref is not "this" in the context of the call, so we
|
||
|
// must extract the function to an independent variable and then call
|
||
|
// that variable, so that "this" is correct (it will be "undefined").
|
||
|
|
||
|
const f = proxy_js_ref[f_ref];
|
||
|
const ret = f();
|
||
|
proxy_convert_js_to_mp_obj_jsside(ret, out);
|
||
|
});
|
||
|
|
||
|
EM_JS(int, call1, (int f_ref, uint32_t * a0, uint32_t * out), {
|
||
|
const a0_js = proxy_convert_mp_to_js_obj_jsside(a0);
|
||
|
const f = proxy_js_ref[f_ref];
|
||
|
const ret = f(a0_js);
|
||
|
proxy_convert_js_to_mp_obj_jsside(ret, out);
|
||
|
});
|
||
|
|
||
|
EM_JS(int, call2, (int f_ref, uint32_t * a0, uint32_t * a1, uint32_t * out), {
|
||
|
const a0_js = proxy_convert_mp_to_js_obj_jsside(a0);
|
||
|
const a1_js = proxy_convert_mp_to_js_obj_jsside(a1);
|
||
|
const f = proxy_js_ref[f_ref];
|
||
|
const ret = f(a0_js, a1_js);
|
||
|
proxy_convert_js_to_mp_obj_jsside(ret, out);
|
||
|
});
|
||
|
|
||
|
EM_JS(int, calln, (int f_ref, uint32_t n_args, uint32_t * value, uint32_t * out), {
|
||
|
const f = proxy_js_ref[f_ref];
|
||
|
const a = [];
|
||
|
for (let i = 0; i < n_args; ++i) {
|
||
|
const v = proxy_convert_mp_to_js_obj_jsside(value + i * 3 * 4);
|
||
|
a.push(v);
|
||
|
}
|
||
|
const ret = f(... a);
|
||
|
proxy_convert_js_to_mp_obj_jsside(ret, out);
|
||
|
});
|
||
|
|
||
|
EM_JS(void, call0_kwarg, (int f_ref, uint32_t n_kw, uint32_t * key, uint32_t * value, uint32_t * out), {
|
||
|
const f = proxy_js_ref[f_ref];
|
||
|
const a = {};
|
||
|
for (let i = 0; i < n_kw; ++i) {
|
||
|
const k = UTF8ToString(getValue(key + i * 4, "i32"));
|
||
|
const v = proxy_convert_mp_to_js_obj_jsside(value + i * 3 * 4);
|
||
|
a[k] = v;
|
||
|
}
|
||
|
const ret = f(a);
|
||
|
proxy_convert_js_to_mp_obj_jsside(ret, out);
|
||
|
});
|
||
|
|
||
|
EM_JS(void, call1_kwarg, (int f_ref, uint32_t * arg0, uint32_t n_kw, uint32_t * key, uint32_t * value, uint32_t * out), {
|
||
|
const f = proxy_js_ref[f_ref];
|
||
|
const a0 = proxy_convert_mp_to_js_obj_jsside(arg0);
|
||
|
const a = {};
|
||
|
for (let i = 0; i < n_kw; ++i) {
|
||
|
const k = UTF8ToString(getValue(key + i * 4, "i32"));
|
||
|
const v = proxy_convert_mp_to_js_obj_jsside(value + i * 3 * 4);
|
||
|
a[k] = v;
|
||
|
}
|
||
|
const ret = f(a0, a);
|
||
|
proxy_convert_js_to_mp_obj_jsside(ret, out);
|
||
|
});
|
||
|
|
||
|
EM_JS(void, js_reflect_construct, (int f_ref, uint32_t n_args, uint32_t * args, uint32_t * out), {
|
||
|
const f = proxy_js_ref[f_ref];
|
||
|
const as = [];
|
||
|
for (let i = 0; i < n_args; ++i) {
|
||
|
as.push(proxy_convert_mp_to_js_obj_jsside(args + i * 4));
|
||
|
}
|
||
|
const ret = Reflect.construct(f, as);
|
||
|
proxy_convert_js_to_mp_obj_jsside(ret, out);
|
||
|
});
|
||
|
|
||
|
EM_JS(int, js_get_len, (int f_ref), {
|
||
|
return proxy_js_ref[f_ref].length;
|
||
|
});
|
||
|
|
||
|
EM_JS(void, js_subscr_int, (int f_ref, int idx, uint32_t * out), {
|
||
|
const f = proxy_js_ref[f_ref];
|
||
|
const ret = f[idx];
|
||
|
proxy_convert_js_to_mp_obj_jsside(ret, out);
|
||
|
});
|
||
|
|
||
|
EM_JS(void, js_subscr_load, (int f_ref, uint32_t * index_ref, uint32_t * out), {
|
||
|
const target = proxy_js_ref[f_ref];
|
||
|
const index = python_index_semantics(target, proxy_convert_mp_to_js_obj_jsside(index_ref));
|
||
|
const ret = target[index];
|
||
|
proxy_convert_js_to_mp_obj_jsside(ret, out);
|
||
|
});
|
||
|
|
||
|
EM_JS(void, js_subscr_store, (int f_ref, uint32_t * idx, uint32_t * value), {
|
||
|
const f = proxy_js_ref[f_ref];
|
||
|
f[proxy_convert_mp_to_js_obj_jsside(idx)] = proxy_convert_mp_to_js_obj_jsside(value);
|
||
|
});
|
||
|
|
||
|
static void jsproxy_print(const mp_print_t *print, mp_obj_t self_in, mp_print_kind_t kind) {
|
||
|
mp_obj_jsproxy_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
mp_printf(print, "<JsProxy %d>", self->ref);
|
||
|
}
|
||
|
|
||
|
static mp_obj_t jsproxy_call(mp_obj_t self_in, size_t n_args, size_t n_kw, const mp_obj_t *args) {
|
||
|
mp_obj_jsproxy_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
|
||
|
if (n_kw == 0) {
|
||
|
mp_arg_check_num(n_args, n_kw, 0, MP_OBJ_FUN_ARGS_MAX, false);
|
||
|
} else {
|
||
|
mp_arg_check_num(n_args, n_kw, 0, 1, true);
|
||
|
uint32_t key[n_kw];
|
||
|
uint32_t value[PVN * n_kw];
|
||
|
for (int i = 0; i < n_kw; ++i) {
|
||
|
key[i] = (uintptr_t)mp_obj_str_get_str(args[n_args + i * 2]);
|
||
|
proxy_convert_mp_to_js_obj_cside(args[n_args + i * 2 + 1], &value[i * PVN]);
|
||
|
}
|
||
|
uint32_t out[3];
|
||
|
if (n_args == 0) {
|
||
|
call0_kwarg(self->ref, n_kw, key, value, out);
|
||
|
} else {
|
||
|
// n_args == 1
|
||
|
uint32_t arg0[PVN];
|
||
|
proxy_convert_mp_to_js_obj_cside(args[0], arg0);
|
||
|
call1_kwarg(self->ref, arg0, n_kw, key, value, out);
|
||
|
}
|
||
|
return proxy_convert_js_to_mp_obj_cside(out);
|
||
|
}
|
||
|
|
||
|
if (n_args == 0) {
|
||
|
uint32_t out[3];
|
||
|
call0(self->ref, out);
|
||
|
return proxy_convert_js_to_mp_obj_cside(out);
|
||
|
} else if (n_args == 1) {
|
||
|
uint32_t arg0[PVN];
|
||
|
uint32_t out[PVN];
|
||
|
proxy_convert_mp_to_js_obj_cside(args[0], arg0);
|
||
|
call1(self->ref, arg0, out);
|
||
|
return proxy_convert_js_to_mp_obj_cside(out);
|
||
|
} else if (n_args == 2) {
|
||
|
uint32_t arg0[PVN];
|
||
|
proxy_convert_mp_to_js_obj_cside(args[0], arg0);
|
||
|
uint32_t arg1[PVN];
|
||
|
proxy_convert_mp_to_js_obj_cside(args[1], arg1);
|
||
|
uint32_t out[3];
|
||
|
call2(self->ref, arg0, arg1, out);
|
||
|
return proxy_convert_js_to_mp_obj_cside(out);
|
||
|
} else {
|
||
|
uint32_t value[PVN * n_args];
|
||
|
for (int i = 0; i < n_args; ++i) {
|
||
|
proxy_convert_mp_to_js_obj_cside(args[i], &value[i * PVN]);
|
||
|
}
|
||
|
uint32_t out[3];
|
||
|
calln(self->ref, n_args, value, out);
|
||
|
return proxy_convert_js_to_mp_obj_cside(out);
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static mp_obj_t jsproxy_reflect_construct(size_t n_args, const mp_obj_t *args) {
|
||
|
int arg0 = mp_obj_jsproxy_get_ref(args[0]);
|
||
|
n_args -= 1;
|
||
|
args += 1;
|
||
|
uint32_t args_conv[n_args];
|
||
|
for (unsigned int i = 0; i < n_args; ++i) {
|
||
|
proxy_convert_mp_to_js_obj_cside(args[i], &args_conv[i * PVN]);
|
||
|
}
|
||
|
uint32_t out[3];
|
||
|
js_reflect_construct(arg0, n_args, args_conv, out);
|
||
|
return proxy_convert_js_to_mp_obj_cside(out);
|
||
|
}
|
||
|
static MP_DEFINE_CONST_FUN_OBJ_VAR(jsproxy_reflect_construct_obj, 1, jsproxy_reflect_construct);
|
||
|
|
||
|
static mp_obj_t jsproxy_subscr(mp_obj_t self_in, mp_obj_t index, mp_obj_t value) {
|
||
|
mp_obj_jsproxy_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
if (value == MP_OBJ_SENTINEL) {
|
||
|
// Load subscript.
|
||
|
uint32_t idx[PVN], out[PVN];
|
||
|
proxy_convert_mp_to_js_obj_cside(index, idx);
|
||
|
js_subscr_load(self->ref, idx, out);
|
||
|
return proxy_convert_js_to_mp_obj_cside(out);
|
||
|
} else if (value == MP_OBJ_NULL) {
|
||
|
// Delete subscript.
|
||
|
return MP_OBJ_NULL; // not supported
|
||
|
} else {
|
||
|
// Store subscript.
|
||
|
uint32_t idx[PVN], val[PVN];
|
||
|
proxy_convert_mp_to_js_obj_cside(index, idx);
|
||
|
proxy_convert_mp_to_js_obj_cside(value, val);
|
||
|
js_subscr_store(self->ref, idx, val);
|
||
|
return mp_const_none;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
void mp_obj_jsproxy_attr(mp_obj_t self_in, qstr attr, mp_obj_t *dest) {
|
||
|
mp_obj_jsproxy_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
if (dest[0] == MP_OBJ_NULL) {
|
||
|
// Load attribute.
|
||
|
uint32_t out[PVN];
|
||
|
if (lookup_attr(self->ref, qstr_str(attr), out)) {
|
||
|
dest[0] = proxy_convert_js_to_mp_obj_cside(out);
|
||
|
} else if (attr == MP_QSTR_new) {
|
||
|
// Special case to handle construction of JS objects.
|
||
|
// JS objects don't have a ".new" attribute, doing "Obj.new" is a Pyodide idiom for "new Obj".
|
||
|
// It translates to the JavaScript "Reflect.construct(Obj, Array(...args))".
|
||
|
dest[0] = MP_OBJ_FROM_PTR(&jsproxy_reflect_construct_obj);
|
||
|
dest[1] = self_in;
|
||
|
}
|
||
|
} else if (dest[1] == MP_OBJ_NULL) {
|
||
|
// Delete attribute.
|
||
|
} else {
|
||
|
// Store attribute.
|
||
|
uint32_t value[PVN];
|
||
|
proxy_convert_mp_to_js_obj_cside(dest[1], value);
|
||
|
store_attr(self->ref, qstr_str(attr), value);
|
||
|
dest[0] = MP_OBJ_NULL;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
/******************************************************************************/
|
||
|
// jsproxy iterator
|
||
|
|
||
|
typedef struct _jsproxy_it_t {
|
||
|
mp_obj_base_t base;
|
||
|
mp_fun_1_t iternext;
|
||
|
int ref;
|
||
|
uint16_t cur;
|
||
|
uint16_t len;
|
||
|
} jsproxy_it_t;
|
||
|
|
||
|
static mp_obj_t jsproxy_it_iternext(mp_obj_t self_in) {
|
||
|
jsproxy_it_t *self = MP_OBJ_TO_PTR(self_in);
|
||
|
if (self->cur < self->len) {
|
||
|
uint32_t out[3];
|
||
|
js_subscr_int(self->ref, self->cur, out);
|
||
|
self->cur += 1;
|
||
|
return proxy_convert_js_to_mp_obj_cside(out);
|
||
|
} else {
|
||
|
return MP_OBJ_STOP_ITERATION;
|
||
|
}
|
||
|
}
|
||
|
|
||
|
static mp_obj_t jsproxy_getiter(mp_obj_t o_in, mp_obj_iter_buf_t *iter_buf) {
|
||
|
assert(sizeof(jsproxy_it_t) <= sizeof(mp_obj_iter_buf_t));
|
||
|
jsproxy_it_t *o = (jsproxy_it_t *)iter_buf;
|
||
|
o->base.type = &mp_type_polymorph_iter;
|
||
|
o->iternext = jsproxy_it_iternext;
|
||
|
o->ref = mp_obj_jsproxy_get_ref(o_in);
|
||
|
o->cur = 0;
|
||
|
o->len = js_get_len(o->ref);
|
||
|
return MP_OBJ_FROM_PTR(o);
|
||
|
}
|
||
|
|
||
|
/******************************************************************************/
|
||
|
|
||
|
MP_DEFINE_CONST_OBJ_TYPE(
|
||
|
mp_type_jsproxy,
|
||
|
MP_QSTR_JsProxy,
|
||
|
MP_TYPE_FLAG_ITER_IS_GETITER,
|
||
|
print, jsproxy_print,
|
||
|
call, jsproxy_call,
|
||
|
attr, mp_obj_jsproxy_attr,
|
||
|
subscr, jsproxy_subscr,
|
||
|
iter, jsproxy_getiter
|
||
|
);
|
||
|
|
||
|
mp_obj_t mp_obj_new_jsproxy(int ref) {
|
||
|
mp_obj_jsproxy_t *o = mp_obj_malloc(mp_obj_jsproxy_t, &mp_type_jsproxy);
|
||
|
o->ref = ref;
|
||
|
return MP_OBJ_FROM_PTR(o);
|
||
|
}
|