use BigInt by default for 'x' and 't'

(Breaking change)

Always use BigInt to represent dbus int64 and uint64 types.

Remove Long.js dependency.

Author: Tony Crisci

.babelrc

@@ -1,6 +1,7 @@
 {
   "plugins": [
     [ "@babel/plugin-proposal-decorators", { "decoratorsBeforeExport": true, "legacy": false } ],
-    "@babel/plugin-proposal-class-properties"
+    "@babel/plugin-proposal-class-properties",
+    "@babel/plugin-syntax-bigint"
   ]
 }

examples/new-service/.babelrc

@@ -1,6 +1,7 @@
 {
   "plugins": [
     [ "@babel/plugin-proposal-decorators", { "decoratorsBeforeExport": true, "legacy": false } ],
-    "@babel/plugin-proposal-class-properties"
+    "@babel/plugin-proposal-class-properties",
+    "@babel/plugin-syntax-bigint"
   ]
 }

examples/new-service/package.json

@@ -6,6 +6,6 @@
         "@babel/plugin-proposal-decorators": "^7.1.2"
     },
     "scripts": {
-        "start": "rm -r build && mkdir build && babel ./index.js -o ./build/index.js && node ./build"
+        "start": "rm -rf build && mkdir build && babel ./index.js -o ./build/index.js && node ./build"
     }
 }

lib/constants.js

@@ -1,4 +1,9 @@
 module.exports = {
+  MAX_INT64: 9223372036854775807n,
+  MIN_INT64: -9223372036854775807n,
+  MAX_UINT64: 18446744073709551615n,
+  MIN_UINT64: 0n,
+
   messageType: {
     invalid: 0,
     methodCall: 1,

lib/dbus-buffer.js

@@ -1,10 +1,9 @@
-const Long = require('long');
 const parseSignature = require('./signature');
 
 // Buffer + position + global start position ( used in alignment )
 function DBusBuffer(buffer, startPos, options) {
   if (typeof options !== 'object') {
-    options = { ayBuffer: true, ReturnLongjs: false };
+    options = { ayBuffer: true };
   } else if (options.ayBuffer === undefined) {
     // default settings object
     options.ayBuffer = true; // enforce truthy default props
@@ -159,19 +158,24 @@ DBusBuffer.prototype.readSimpleType = function readSimpleType(t) {
     case 'x':
       //signed
       this.align(3);
-      word0 = this.readInt32();
-      word1 = this.readInt32();
-      data = Long.fromBits(word0, word1, false);
-      if (this.options.ReturnLongjs) return data;
-      return data.toNumber(); // convert to number (good up to 53 bits)
+      word0 = BigInt(this.readInt32());
+      word1 = BigInt(this.readInt32());
+
+      let word1Stripped = word1 & ~(1n << 31n);
+
+      let data = (word1Stripped << 32n) + word0;
+
+      if (word1Stripped !== word1) {
+        data *= -1n;
+      }
+
+      return data;
     case 't':
       //unsigned
       this.align(3);
-      word0 = this.readInt32();
-      word1 = this.readInt32();
-      data = Long.fromBits(word0, word1, true);
-      if (this.options.ReturnLongjs) return data;
-      return data.toNumber(); // convert to number (good up to 53 bits)
+      word0 = BigInt(this.readInt32());
+      word1 = BigInt(this.readInt32());
+      return (word1 << BigInt(32)) + word0;
     case 'd':
       return this.readDouble();
     default:

lib/marshallers.js

@@ -1,7 +1,11 @@
 const Buffer = require('safe-buffer').Buffer;
 const align = require('./align').align;
 const parseSignature = require('../lib/signature');
-const Long = require('long');
+const {
+  MAX_INT64, MIN_INT64,
+  MAX_UINT64, MIN_UINT64
+} = require('./constants');
+
 /**
  * MakeSimpleMarshaller
  * @param signature - the signature of the data you want to check
@@ -178,8 +182,10 @@ var MakeSimpleMarshaller = function(signature) {
       marshaller.marshall = function(ps, data) {
         data = this.check(data);
         align(ps, 8);
-        ps.word32le(data.low);
-        ps.word32le(data.high);
+        let word0 = data - ((data >> 32n) << 32n);
+        let word1 = data >> 32n;
+        ps.word32le(Number(word0));
+        ps.word32le(Number(word1));
         ps._offset += 8;
       };
       break;
@@ -190,9 +196,22 @@ var MakeSimpleMarshaller = function(signature) {
       };
       marshaller.marshall = function(ps, data) {
         data = this.check(data);
+        let isNegative = (data < 0n);
+        if (isNegative) {
+          data *= -1n;
+        }
+
+        let word0 = data - ((data >> 32n) << 32n);
+        let word1 = data >> 32n;
+
+        if (isNegative) {
+          word1 |= (1n << 31n);
+        }
+
         align(ps, 8);
-        ps.word32le(data.low);
-        ps.word32le(data.high);
+        ps.word32le(Number(word0));
+        ps.word32le(Number(word1));
+
         ps._offset += 8;
       };
       break;
@@ -243,94 +262,22 @@ var checkBoolean = function(data) {
     throw new Error(`Data: ${data} was not of type boolean`);
 };
 
-// This is essentially a tweaked version of 'fromValue' from Long.js with error checking.
-// This can take number or string of decimal characters or 'Long' instance (or Long-style object with props low,high,unsigned).
-var makeLong = function(val, signed) {
-  if (val instanceof Long) return val;
-  if (val instanceof Number) val = val.valueOf();
-  if (typeof val === 'number') {
-    try {
-      // Long.js won't alert you to precision loss in passing more than 53 bit ints through a double number, so we check here
-      checkInteger(val);
-      if (signed) {
-        checkRange(-0x1fffffffffffff, 0x1fffffffffffff, val);
-      } else {
-        checkRange(0, 0x1fffffffffffff, val);
-      }
-    } catch (e) {
-      e.message += ' (Number type can only carry 53 bit integer)';
-      throw e;
-    }
-    try {
-      return Long.fromNumber(val, !signed);
-    } catch (e) {
-      e.message = `Error converting number to 64bit integer "${e.message}"`;
-      throw e;
-    }
-  }
-  if (typeof val === 'string' || val instanceof String) {
-    var radix = 10;
-    val = val.trim().toUpperCase(); // remove extra whitespace and make uppercase (for hex)
-    if (val.substring(0, 2) === '0X') {
-      radix = 16;
-      val = val.substring(2);
-    } else if (val.substring(0, 3) === '-0X') {
-      // unusual, but just in case?
-      radix = 16;
-      val = `-${val.substring(3)}`;
-    }
-    val = val.replace(/^0+(?=\d)/, ''); // dump leading zeroes
-    var data;
-    try {
-      data = Long.fromString(val, !signed, radix);
-    } catch (e) {
-      e.message = `Error converting string to 64bit integer '${e.message}'`;
-      throw e;
-    }
-    // If string represents a number outside of 64 bit range, it can quietly overflow.
-    // We assume if things converted correctly the string coming out of Long should match what went into it.
-    if (data.toString(radix).toUpperCase() !== val)
-      throw new Error(
-        `Data: '${val}' did not convert correctly to ${
-          signed ? 'signed' : 'unsigned'
-        } 64 bit`
-      );
-    return data;
-  }
-  // Throws for non-objects, converts non-instanceof Long:
-  try {
-    return Long.fromBits(val.low, val.high, val.unsigned);
-  } catch (e) {
-    e.message = `Error converting object to 64bit integer '${e.message}'`;
-    throw e;
-  }
-};
-
 var checkLong = function(data, signed) {
-  if (!Long.isLong(data)) {
-    data = makeLong(data, signed);
-  }
+  data = BigInt(data);
 
-  // Do we enforce that Long.js object unsigned/signed match the field even if it is still in range?
-  // Probably, might help users avoid unintended bugs?
   if (signed) {
-    if (data.unsigned)
-      throw new Error(
-        'Longjs object is unsigned, but marshalling into signed 64 bit field'
-      );
-    if (data.gt(Long.MAX_VALUE) || data.lt(Long.MIN_VALUE)) {
-      throw new Error(`Data: ${data} was out of range (64-bit signed)`);
+    if (data > MAX_INT64) {
+      throw new Error('data was out of range (greater than max int64)');
+    } else if (data < MIN_INT64) {
+      throw new Error('data was out of range (less than min int64)');
     }
   } else {
-    if (!data.unsigned)
-      throw new Error(
-        'Longjs object is signed, but marshalling into unsigned 64 bit field'
-      );
-    // NOTE: data.gt(Long.MAX_UNSIGNED_VALUE) will catch if Long.js object is a signed value but is still within unsigned range!
-    //  Since we are enforcing signed type matching between Long.js object and field, this note should not matter.
-    if (data.gt(Long.MAX_UNSIGNED_VALUE) || data.lt(0)) {
-      throw new Error(`Data: ${data} was out of range (64-bit unsigned)`);
+    if (data > MAX_UINT64) {
+      throw new Error('data was out of range (greater than max uint64)');
+    } else if (data < MIN_UINT64) {
+      throw new Error('data was out of range (less than min uint64)');
     }
   }
+
   return data;
 };

package.json

@@ -35,7 +35,6 @@
   "dependencies": {
     "event-stream": "3.3.4",
     "hexy": "^0.2.10",
-    "long": "^4.0.0",
     "optimist": "^0.6.1",
     "put": "0.0.6",
     "safe-buffer": "^5.1.1",
@@ -48,6 +47,7 @@
     "@babel/core": "^7.1.5",
     "@babel/plugin-proposal-class-properties": "^7.1.0",
     "@babel/plugin-proposal-decorators": "^7.1.2",
+    "@babel/plugin-syntax-bigint": "^7.2.0",
     "babel-core": "^7.0.0-bridge.0",
     "babel-jest": "^23.6.0",
     "commander": "^2.19.0",

test/integration/long.test.js

@@ -0,0 +1,78 @@
+// Test that methods and properties of type 'x' (long int) work correctly
+
+let dbus = require('../../');
+
+let {
+  Interface, property, method, signal,
+  ACCESS_READ, ACCESS_WRITE, ACCESS_READWRITE
+} = dbus.interface;
+
+let {
+  MAX_INT64, MIN_INT64,
+  MAX_UINT64, MIN_UINT64
+} = require('../../lib/constants');
+
+const TEST_NAME = 'org.test.name';
+const TEST_PATH = '/org/test/path';
+const TEST_IFACE = 'org.test.iface';
+
+let bus = dbus.sessionBus();
+
+class LongInterface extends Interface {
+  @method({inSignature: 'x', outSignature: 'x'})
+  EchoSigned(what) {
+    return what;
+  }
+
+  @method({inSignature: 't', outSignature: 't'})
+  EchoUnsigned(what) {
+    return what;
+  }
+}
+
+let testIface = new LongInterface(TEST_IFACE);
+
+beforeAll(async () => {
+  await bus.export(TEST_NAME, TEST_PATH, testIface);
+});
+
+afterAll(() => {
+  bus.connection.stream.end();
+});
+
+test('test long type works correctly', async () => {
+  let object = await bus.getProxyObject(TEST_NAME, TEST_PATH);
+  let test = object.getInterface(TEST_IFACE);
+
+  // small numbers
+  let what = -30n;
+  let result = await test.EchoSigned(what);
+  // XXX jest does not support bigint yet
+  expect(result === what).toEqual(true);
+
+  what = 30n;
+  result = await test.EchoUnsigned(what);
+  expect(result === what).toEqual(true);
+  result = await test.EchoSigned(what);
+  expect(result === what).toEqual(true);
+
+  // int64 max
+  what = MAX_INT64;
+  result = await test.EchoSigned(what);
+  expect(result === what).toEqual(true);
+
+  // int64 min
+  what = MIN_INT64;
+  result = await test.EchoSigned(what);
+  expect(result === what).toEqual(true);
+
+  // uint64 max
+  what = MAX_UINT64;
+  result = await test.EchoUnsigned(what);
+  expect(result === what).toEqual(true);
+
+  // uint64 min
+  what = MIN_UINT64;
+  result = await test.EchoUnsigned(what);
+  expect(result === what).toEqual(true);
+});