Type conversion

Implicit convert

In js-ctypes, data could be converted implicitly when passing to or returning from a FunctionType call, or setting pointer content, an array element or a struct field.

var buffer = ctypes.char.array(10)();

var someCFunction = library.declare("someCFunction", ctypes.default_abi, ctypes.void_t, ctypes.char.ptr);

someCFunction(buffer); // here ctypes.char.array(10)() is converted to ctypes.char.ptr type

Implicit conversion can be tested in the following way:

var myStruct = ctypes.StructType("myStructType", [
  { "v": ctypes.bool }
])();
myStruct.v = 1;
console.log(myStruct.v.toString()); // 'true'

Boolean type

var myStruct = ctypes.StructType("myStructType", [
  { "v": ctypes.bool }
])();

myStruct.v = true;
console.log(myStruct.v.toString()); // 'true'
myStruct.v = false;
console.log(myStruct.v.toString()); // 'false'
myStruct.v = 1;
console.log(myStruct.v.toString()); // 'true'
myStruct.v = 0;
console.log(myStruct.v.toString()); // 'false'

myStruct.v = 10;         // throws Error
myStruct.v = "a";        // throws Error

Integer types

var myStruct = ctypes.StructType("myStructType", [
  { "v": ctypes.char16_t }
])();

myStruct.v = 0x41;
console.log(myStruct.v.toString()); // "A"
myStruct.v = true;
console.log(myStruct.v.toString()); // "\x01"
myStruct.v = "X";
console.log(myStruct.v.toString()); // "X"

myStruct.v = "XX";                  // throws Error

var myStruct = ctypes.StructType("myStructType", [
  { "v": ctypes.int16_t }
])();

myStruct.v = 0x41;
console.log(myStruct.v.toString()); // 65
myStruct.v = true;
console.log(myStruct.v.toString()); // 1

myStruct.v = "X";                   // throws Error

Integer/float types are implicitly convertible if any data of source type could be representable in the target type.

Note that the following table does not contain environment dependent types (ctypes.long, etc.).

var myStruct = ctypes.StructType("myStructType", [
  { "v": ctypes.int16_t }
])();

myStruct.v = ctypes.int8_t(10);
console.log(myStruct.v.toString()); // 10

myStruct.v = ctypes.int32_t(10);    // throws Error

Float types

Pointer types

var myStruct = ctypes.StructType("myStructType", [
  { "v": ctypes.int16_t.ptr }
])();

myStruct.v = ctypes.int16_t.array(10)();
console.log(myStruct.v.toString());      // 'ctypes.int16_t.ptr(ctypes.UInt64("0x11d6ff400"))'
myStruct.v = null;
console.log(myStruct.v.toString());      // 'ctypes.int16_t.ptr(ctypes.UInt64("0x0"))'

myStruct.v = ctypes.int32_t.array(10)(); // throws Error

Only in FunctionType argument, the following rules are also applied:

var myFuncType = ctypes.FunctionType(ctypes.default_abi, ctypes.void_t, [ctypes.int16_t.ptr]);
var myFunc = myFuncType.ptr(function(v) { console.log(v.toString()); });

myFunc(Int16Array([1, 2, 3])); // 'ctypes.int16_t.ptr(ctypes.UInt64("0x103b7fe60"))'
myFunc(Int32Array([1, 2, 3])); // throws Error

var myFuncType = ctypes.FunctionType(ctypes.default_abi, ctypes.void_t, [ctypes.char.ptr]);
var myFunc = myFuncType.ptr(function(v) { console.log(v.toString()); });

myFunc("abcde");               // 'ctypes.char.ptr(ctypes.UInt64("0x101d1d680"))'
myFunc(Int32Array([1, 2, 3])); // 'ctypes.char.ptr(ctypes.UInt64("0x103b7ffe0"))'

Array types

var myStruct = ctypes.StructType("myStructType", [
  { "v": ctypes.int16_t.array(5) }
])();

myStruct.v = [1, 2, 3, 4, 5];
console.log(myStruct.v.toString()); // 'ctypes.int16_t.array(5)([0, 0, 0, 0, 0])'
myStruct.v = Int16Array([1, 2, 3, 4, 5]);
console.log(myStruct.v.toString()); // 'ctypes.int16_t.array(5)([1, 2, 3, 4, 5])'

myStruct.v = [1, 2, 3, 4];          // throws Error

var myStruct = ctypes.StructType("myStructType", [
  { "v": ctypes.char.array(5) }
])();

myStruct.v = "abcde";
console.log(myStruct.v.toString()); // 'ctypes.char.array(5)([97, 98, 99, 100, 101])'
myStruct.v = "abc";
console.log(myStruct.v.toString()); // 'ctypes.char.array(5)([97, 98, 99, 0, 0])'

myStruct.v = myStruct.v = "abcdef"; // throws Error

Struct types

JS object can be converted into struct type:

var POINT = ctypes.StructType("POINT", [
  { x: ctypes.int32_t },
  { y: ctypes.int32_t },
]);

var myStruct = ctypes.StructType("myStructType", [
  { "v": POINT }
])();

myStruct.v = {
  x: 10,
  y: 20
};
console.log(myStruct.v.toString()); // 'POINT(10, 20)'

myStruct.v = {
  x: 10
};                                  // throws Error

myStruct.v = {
  x: 10,
  y: 20,
  z: 30
};                                  // throws Error

myStruct.v = {
  x: 10,
  z: 10
};                                  // throws Error

Explicit convert

In js-ctypes, data could be converted explicitly, when passing to CData constructor:

ctypes.int32_t("123"); // string "123" is parsed as 10-base string

Explicit convert tries implicit convert first, and if it fails, the following rules are applied:

Boolean type

console.log(ctypes.bool("123").toString()); // 'ctypes.bool(true)'
console.log(ctypes.bool("").toString());    // 'ctypes.bool(false)'

Integer types

console.log(ctypes.int32_t(Infinity).toString());         // 'ctypes.int32_t(0)'
console.log(ctypes.int32_t("0xff").toString()));          // 'ctypes.int32_t(255)'
console.log(ctypes.int32_t(ctypes.Int64(10)).toString()); // 'ctypes.int32_t(10)'

Pointer types

console.log(ctypes.int32_t.ptr(0xfffffffff).toString()); // 'ctypes.int32_t.ptr(ctypes.UInt64("0xfffffffff"))'

See Also

• Working with ArrayBuffers