Allow calling stored JS functions.

Author: PetterS

module.c

@@ -25,18 +25,42 @@ static PyObject *object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
 }
 
 static void object_dealloc(ObjectData *self) {
+if (self->context) {
+JS_FreeValue(self->context, self->object);
+}
 Py_TYPE(self)->tp_free((PyObject *)self);
 }
 
-static PyObject *object_call(ObjectData *self, PyObject *args) {
-if (self->context) {
-JS_FreeValue(self->context, self->object);
+static PyObject *object_call(ObjectData *self, PyObject *args, PyObject *kwds) {
+if (self->context == NULL) {
+Py_RETURN_NONE;
 }
-Py_RETURN_NONE;
+const int nargs = PyTuple_Size(args);
+for (int i = 0; i < nargs; ++i) {
+PyObject *item = PyTuple_GetItem(args, i);
+if (PyLong_Check(item)) {
+} else {
+PyErr_Format(PyExc_ValueError, "Unsupported type when calling quickjs object");
+return NULL;
+}
+}
+JSValueConst *jsargs = malloc(nargs * sizeof(JSValueConst));
+for (int i = 0; i < nargs; ++i) {
+PyObject *item = PyTuple_GetItem(args, i);
+if (PyLong_Check(item)) {
+jsargs[i] = JS_MKVAL(JS_TAG_INT, PyLong_AsLong(item));
+}
+}
+JSValue value = JS_Call(self->context, self->object, JS_NULL, 1, jsargs);
+for (int i = 0; i < nargs; ++i) {
+JS_FreeValue(self->context, jsargs[i]);
+}
+free(jsargs);
+return quickjs_to_python(self->context, value);
 }
 
 static PyMethodDef object_methods[] = {
- {"call", (PyCFunction)object_call, METH_VARARGS, "Calls a JS function."}, {NULL} /* Sentinel */
+ {NULL} /* Sentinel */
 };
 
 static PyTypeObject Object = {PyVarObject_HEAD_INIT(NULL, 0).tp_name = "_quickjs.Object",
@@ -46,6 +70,7 @@ static PyTypeObject Object = {PyVarObject_HEAD_INIT(NULL, 0).tp_name = "_quickjs
  .tp_flags = Py_TPFLAGS_DEFAULT,
  .tp_new = object_new,
  .tp_dealloc = (destructor)object_dealloc,
+ .tp_call = object_call,
  .tp_methods = object_methods};
 
 static PyObject *quickjs_to_python(JSContext *context, JSValue value) {

test_quickjs.py

@@ -40,20 +40,37 @@ def test_context_between_calls(self):
 
  def test_function(self):
  self.context.eval("""
- function special(x) {
- return 40 + x;
- }
- """)
+  function special(x) {
+  return 40 + x;
+  }
+  """)
  self.assertEqual(self.context.eval("special(2)"), 42)
 
  def test_function_is_object(self):
  f = self.context.eval("""
- a = function(x) {
- return 40 + x;
- }
- """)
+  a = function(x) {
+  return 40 + x;
+  }
+  """)
  self.assertIsInstance(f, quickjs.Object)
 
+ def test_function_call(self):
+ f = self.context.eval("""
+ f = function(x) {
+ return 40 + x;
+ }
+ """)
+ self.assertEqual(f(2), 42)
+
+ def test_function_call_unsupported_arg(self):
+ f = self.context.eval("""
+ f = function(x) {
+ return 40 + x;
+ }
+ """)
+ with self.assertRaisesRegex(ValueError, "Unsupported type"):
+ self.assertEqual(f({}), 42)
+
  def test_error(self):
  with self.assertRaisesRegex(quickjs.JSException, "ReferenceError: missing is not defined"):
  self.context.eval("missing + missing")