Instantiate an object of some class in native code

[tve]

I'd like a native code function to return an object of a given class and I'm coming up a bit short on how to accomplish that. I'd really appreciate a little example or some pointers.

I have the following class in vec3.js that I will want to instantiate and return from a native function:

export class Vec3 {
  constructor(x, y, z) {
    this.x = x
    this.y = y
    this.z = z
  }

  scale(n) {
    this.x *= n
    this.y *= n
    this.z *= n
  }
}

The scale function is not important, I just wanted to have a member function there.

I have the following JS portion of a native module:

export function testVec3A(vec, a) @ "xs_testVec3A";
// vec.x = a; vec.y = 2*a; vec.z = 4*a; return vec;

export function testVec3B(a) @ "xs_testVec3B";
// return new Vec3(a, 2*a, 4*a);

The first function testVec3A I know how to implement. It takes a Vec3 object and sets its fields, and then returns it. What I'd like to implement is testVec3B which does almost the same thing, but instantiates the Vec3.

Here's modTest.c:

#include "xsmc.h"

void xs_testVec3A(xsMachine *the)
{
  xsmcVars(1);
  // arg0.x = arg1
  xsmcSet(xsArg(0), xsID("x"), xsArg(1));
  // arg0.y = 2*arg1
  double a = xsmcToNumber(xsArg(1));
  a *= 2;
  xsmcSetNumber(xsVar(0), a);
  xsmcSet(xsArg(0), xsID("y"), xsVar(0));
  // arg0.z = 4*arg1
  a *= 2;
  xsmcSetNumber(xsVar(0), a);
  xsmcSet(xsArg(0), xsID("z"), xsVar(0));
  // return arg0
  xsResult = xsArg(0);
}

The question now is:

void xs_testVec3B(xsMachine *the)
{
}

Where I'm stuck:

• I believe I need to get a handle onto the prototype for Vec3 in module 'vec3.js'
• I then need to instantiate a Vec3 object
• and call the constructor (I believe I can handle that)

Help appreciated!

I'm attaching a complete project, run with mcconfig -d -m -p lin-or- [repro-xsmc.tar.gz](https://github.com/Moddable-OpenSource/moddable/files/11711485/repro-xsmc.tar.gz) mac: repro-xsmc.tar.gz

That project has an extra native function that returns a created ArrayBuffer. Ideally I'd like to return a Float64Array based on that buffer instead, I hope doing that will be very similar to the Vec3 stuff above.

[salarizadi]

@tve

I'm not sure I understand what you mean, but I have some suggestions for you to get the values :

`
class Vec3 {
constructor(x, y, z) {
this.x = x
this.y = y
this.z = z
return new Float64Array([
this.x,
this.y,
this.z
])
}

scale(n) {
this.x *= n
this.y *= n
this.z *= n
}
}

const $vec3 = new Vec3(
12, 24, 6
)

trace(JSON.stringify($vec3))
`

C : Example of SD card module return object values

[tve]

I suppose the calling convention on macOS (ARM64?) passes structs (xsSlot) as pointers...

[phoddie]

Yes, that seems likely. I updated the docs to avoid unnecessary confusion moving forward. Thanks for pointing that out.

[tve]

@phoddie I'm again trying to create an object in native code... Instead of creating a global variable and then looking that up, is it possible to pass the constructor to native code and then call it there?
E.g.:

  // create a Quaternion object and populate with values
  get quaternion () { return this._quaternion(Object.getPrototypeOf(Quaternion)) };
  // given Quaternion prototype, construct one and populate with values
  _quaternion (Quaternion) @ "xs_FusionAhrsGetQuaternion";

void xs_FusionAhrsGetQuaternion(xsMachine *the)
{
  FusionAhrs *ahrs = xsmcGetHostChunk(xsThis);
  xsmcVars(4);
  xsmcSetNumber(xsmcVar(0), ahrs->quaternion.element.w);
  xsmcSetNumber(xsmcVar(1), ahrs->quaternion.element.x);
  xsmcSetNumber(xsmcVar(2), ahrs->quaternion.element.y);
  xsmcSetNumber(xsmcVar(3), ahrs->quaternion.element.z);
  xsmcNew(xsResult, xsArg(0), xsID_constructor, &xsmcVar(0), &xsmcVar(1), &xsmcVar(2), &xsmcVar(3));
}

This code isn't working, I get a "no function" exception. I tried passing Quaternion into this._quaternion with the same effect. Is there a permutation of this that would work?

[phoddie]

Instead of creating a global variable and then looking that up, is it possible to pass the constructor to native code and then call it there?

This is possible. It is a little strange though.

I understand that it isn't always desirable to store the constructor in a global. Another option is to store the constructor on the prototype of the object with the native function. That way the the native code can look it up. In your case, that would be something like AHS.prototype.Quaternion = Quaternion. Then you can use xsmcNew on xsThis and the xsID_Quaternion property. That approach avoids needing an intermediate JavaScript function between the caller and the native code to insert the constructor.

To do what you describe, you need a slightly different way to call the constructor. xsmcNew retrieves the constructor from an object. Here you have the function so there's no object. There's no macro (yet) in xs.h or xsmc.h for that, but Piu has them as xsNewFunction1 and friends. (We should probably move these to xs.h. Maybe this is a good motivation...) If it is messy to include "piuAll.h" you can just copy the macros to start to try it out. Please let me know how it goes.

[tve]

Why do you find this solution strange? It avoids polluting the global namespace and it avoids name collisions. Your solution of storing the constructor in the prototype is also nice and avoids the extra function call.
One nice attribute of both methods is that they support duck typing, so the native code doesn't need to know the exact name of the constructed type as long as the passed in constructor parameters fit.
Thanks for the pointers to Piu's macros.

[phoddie]

Why do you find this solution strange?

It is uncommon to require passing a constructor as an argument to a "get". (It is allowed and it is not unheard of -- in an indirect way ECMA-419 does it). If you prefer that direction, it would be worth considering passing an instance instead of the constructor. That still allows the caller to choose the constructor and allows an instance to be re-used, reducing GC churn.

One nice attribute of both methods is that they support duck typing, so the native code doesn't need to know the exact name of the constructed type as long as the passed in constructor parameters fit.

Agreed. I think that's a nice side-effect. The approach I suggested is very roughly analogous to Symbol.species -- but that is out-of-favor these days (for reasons that aren't relevant to your situation).

[tve]

The trick via the prototype works nicely. For the record:

export class AHRS @ "xs_FusionAhrsDestroy" {
  ...
  get quaternion () @ "xs_FusionAhrsGetQuaternion";
  ...
}
AHRS.prototype.Quaternion = Quaternion

and

void xs_FusionAhrsGetQuaternion(xsMachine *the)
{
  FusionAhrs *ahrs = xsmcGetHostChunk(xsThis);
  xsmcVars(4);
  xsmcSetNumber(xsmcVar(0), ahrs->quaternion.element.w);
  xsmcSetNumber(xsmcVar(1), ahrs->quaternion.element.x);
  xsmcSetNumber(xsmcVar(2), ahrs->quaternion.element.y);
  xsmcSetNumber(xsmcVar(3), ahrs->quaternion.element.z);
  // the following assumes this.Quaternion is the constructor we need to invoke
  xsmcNew(xsResult, xsThis, xsID_Quaternion, &xsmcVar(0), &xsmcVar(1), &xsmcVar(2), &xsmcVar(3), NULL);
}

BTW, I don't know how you changed the docs for xsmcNew but it's worth noting that the variable-length argument list must be terminated by a NULL. I assume this is also the case for xsmcCall where it's neither noted nor shown in the examples. I forgot this in my code and the results were not pretty... (reset)

[phoddie]

Thanks for sharing the working code. That looks great to me.

BTW, I don't know how you changed the docs for xsmcNew but it's worth noting that the variable-length argument list must be terminated by a NULL. I assume this is also the case for xsmcCall where it's neither noted nor shown in the examples.

Thanks. Yes, I did that earlier in the week. It'll propagate our tomorrow.