Fix toInt32 and toUint32 around NaN and Infinity

Operation.fold depended on a faulty implementation of toInt32 and toUint32.


Submitted @3891

[DavidSarah, 2009-11-20 18:23:34]

http://codereview.appspot.com/157109/diff/1003/6
File src/com/google/caja/parser/js/Operation.java (left):

http://codereview.appspot.com/157109/diff/1003/6#oldcode681
src/com/google/caja/parser/js/Operation.java:681: return (int) n;
(int) converts NaN to 0, so that doesn't need to be treated specially.

Also, (int) clamps to the range of an int, whereas step 4 of ToInt32 takes the
value mod 2^32. I think you need to use floating-point % -- see
http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.17.3 .

Suggest also adding a reference to
http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#25363

http://codereview.appspot.com/157109/diff/1003/6#oldcode685
src/com/google/caja/parser/js/Operation.java:685: return ((long) n) &
0xffffffffL;
Similar comment to above -- this is clamping to the range of long *before*
taking the value mod 2^32.

[DavidSarah, 2009-11-20 20:01:07]

This is surprisingly tricky. I think the following is correct.


private static final double TwoToThe32 = 4294967296.0;

// For ToInt32 and ToUInt32, see sections 9.5 and 9.6 of ES5
//   http://wiki.ecmascript.org/doku.php?id=es3.1:es3.1_proposal_working_draft
//
// For Java %, see
//  
http://java.sun.com/docs/books/jls/third_edition/html/expressions.html#15.17.3
//
// For Java (int) and (long), see
//  
http://java.sun.com/docs/books/jls/third_edition/html/conversions.html#25363

public static long toInt32(double n) {
  double d = (n < 0.0 ? Math.ceil(n) : Math.floor(n)) % TwoToThe32;
  if (d < 0.0) d += TwoToThe32;

  // If n is an infinity or NaN, then d will be NaN, which
  // is converted to 0 by (int). Otherwise, d is mathematically
  // equal to int32bit in the algorithm for ToInt32.

  return (int) d;
}

public static long toUInt32(double n) {
  double d = (n < 0.0 ? Math.ceil(n) : Math.floor(n)) % TwoToThe32;
  if (d < 0.0) d += TwoToThe32;

  // If n is an infinity or NaN, then d will be NaN, which
  // is converted to 0 by (long). Otherwise, d is mathematically
  // equal to int32bit in the algorithm for ToInt32.

  return (long) d;
}

[DavidSarah, 2009-11-20 20:05:46]

Typo in the last comment: should be "in the algorithm for ToUint32".

(Note the case of "i"; that should also be fixed in the top comment
and possibly the method name.)

[metaweta, 2009-12-04 18:47:14]

Nice tests.  LGTM.  (It might be worth running them in Rhino once.)

[MikeSamuel, 2009-12-04 19:00:22]

I ran the below in Rhino and got

js> load('/tmp/t')
js: "/tmp/t", line 2: exception from uncaught JavaScript throw: Error: should
fail !== at end of tests
        at /tmp/t:2 (assertEquals)
        at /tmp/t:85
        at <stdin>:8

It's the relevant portions of ExpressionTest with some stubs, and numeric casts
and numeric suffixes removed.


function assertEquals(a, b) {
  if (a !== b) { throw new Error(a + ' !== ' + b); }
}

var Operation = {
toInt32: function (n) { return n | 0; },
toUint32: function (n) { return n >>> 0; }
};

var Double = {
  POSITIVE_INFINITY: 1 / 0,
  NEGATIVE_INFINITY: -1 / 0,
  NaN: NaN
};

    assertEquals(0, Operation.toInt32(0));
    assertEquals(0, Operation.toInt32(-0));
    assertEquals(0, Operation.toInt32(Double.POSITIVE_INFINITY));
    assertEquals(0, Operation.toInt32(Double.NEGATIVE_INFINITY));
    assertEquals(0, Operation.toInt32(Double.NaN));
    assertEquals(0, Operation.toInt32(0x100000000));
    assertEquals(0, Operation.toInt32(-0x100000000));
    assertEquals(0x7fffffff, Operation.toInt32(0x7fffffff));
    assertEquals(-0x7fffffff, Operation.toInt32(-0x7fffffff));
    assertEquals(-0x80000000, Operation.toInt32(-0x80000000));
    assertEquals(-0x80000000, Operation.toInt32(0x80000000));
    assertEquals(1, Operation.toInt32(1));
    assertEquals(-1, Operation.toInt32(-1));
    assertEquals(2, Operation.toInt32(2));
    assertEquals(-2, Operation.toInt32(-2));
    assertEquals( 1e6, Operation.toInt32(1e6));
    assertEquals( 1e7, Operation.toInt32(1e7));
    assertEquals( 1e8, Operation.toInt32(1e8));
    assertEquals( 1e9, Operation.toInt32(1e9));
    assertEquals(1410065408, Operation.toInt32(1e10));
    assertEquals(1215752192, Operation.toInt32(1e11));
    assertEquals(-727379968, Operation.toInt32(1e12));
    assertEquals( -1e6, Operation.toInt32(-1e6));
    assertEquals( -1e7, Operation.toInt32(-1e7));
    assertEquals( -1e8, Operation.toInt32(-1e8));
    assertEquals( -1e9, Operation.toInt32(-1e9));
    assertEquals(-1410065408, Operation.toInt32(-1e10));
    assertEquals(-1215752192, Operation.toInt32(-1e11));
    assertEquals(727379968, Operation.toInt32(-1e12));
    assertEquals(0, Operation.toInt32(0.5));
    assertEquals(0, Operation.toInt32(-0.5));
    assertEquals(1, Operation.toInt32(1.5));
    assertEquals(-1, Operation.toInt32(-1.5));

    assertEquals(0, Operation.toUint32(0));
    assertEquals(0, Operation.toUint32(-0));
    assertEquals(0, Operation.toUint32(Double.POSITIVE_INFINITY));
    assertEquals(0, Operation.toUint32(Double.NEGATIVE_INFINITY));
    assertEquals(0, Operation.toUint32(Double.NaN));
    assertEquals(0, Operation.toUint32(0x100000000));
    assertEquals(0, Operation.toUint32(-0x100000000));
    assertEquals(0x7fffffff, Operation.toUint32(0x7fffffff));
    assertEquals(0x80000001, Operation.toUint32(-0x7fffffff));
    assertEquals(0x80000000, Operation.toUint32(-0x80000000));
    assertEquals(0x80000000, Operation.toUint32(0x80000000));
    assertEquals(1, Operation.toUint32(1));
    assertEquals(0xffffffff, Operation.toUint32(-1));
    assertEquals(2, Operation.toUint32(2));
    assertEquals(0xfffffffe, Operation.toUint32(-2));
    assertEquals( 1e6, Operation.toUint32(1e6));
    assertEquals( 1e7, Operation.toUint32(1e7));
    assertEquals( 1e8, Operation.toUint32(1e8));
    assertEquals( 1e9, Operation.toUint32(1e9));
    assertEquals(1410065408, Operation.toUint32(1e10));
    assertEquals(1215752192, Operation.toUint32(1e11));
    assertEquals(3567587328, Operation.toUint32(1e12));
    assertEquals( (0x100000000 - 1e6), Operation.toUint32(-1e6));
    assertEquals( (0x100000000 - 1e7), Operation.toUint32(-1e7));
    assertEquals( (0x100000000 - 1e8), Operation.toUint32(-1e8));
    assertEquals( (0x100000000 - 1e9), Operation.toUint32(-1e9));
    assertEquals(2884901888, Operation.toUint32(-1e10));
    assertEquals(3079215104, Operation.toUint32(-1e11));
    assertEquals(727379968, Operation.toUint32(-1e12));
    assertEquals(0, Operation.toUint32(0.5));
    assertEquals(0, Operation.toUint32(-0.5));
    assertEquals(1, Operation.toUint32(1.5));
    assertEquals(0xffffffff, Operation.toUint32(-1.5));


assertEquals('should fail', 'at end of tests');

[DavidSarah, 2009-12-05 01:06:11]

LGTM