Revert of Remove obsolete V8_INFINITY macro.

test/cctest/test-strtod.cc

 // Copyright 2006-2008 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 182 matching lines @@
   CHECK_EQ(40000e-328, StrtodChar("30000", -328));
   CHECK_EQ(0.0, StrtodChar("10000", -329));
   CHECK_EQ(0.0, StrtodChar("90000", -329));
   CHECK_EQ(0.0, StrtodChar("000000001", -325));
   CHECK_EQ(0.0, StrtodChar("000000001", -325));
   CHECK_EQ(0.0, StrtodChar("0000000020000", -328));
   CHECK_EQ(40000e-328, StrtodChar("00000030000", -328));
   CHECK_EQ(0.0, StrtodChar("0000000010000", -329));
   CHECK_EQ(0.0, StrtodChar("0000000090000", -329));
 
-  // It would be more readable to put the literals (and not
-  // std::numeric_limits<double>::infinity()) on the
+  // It would be more readable to put the literals (and not V8_INFINITY) on the
   // left side (i.e. CHECK_EQ(1e309, StrtodChar("1", 309))), but then Gcc
   // complains that the floating constant exceeds range of 'double'.
-  CHECK_EQ(std::numeric_limits<double>::infinity(), StrtodChar("1", 309));
+  CHECK_EQ(V8_INFINITY, StrtodChar("1", 309));
   CHECK_EQ(1e308, StrtodChar("1", 308));
   CHECK_EQ(1234e305, StrtodChar("1234", 305));
   CHECK_EQ(1234e304, StrtodChar("1234", 304));
-  CHECK_EQ(std::numeric_limits<double>::infinity(), StrtodChar("18", 307));
+  CHECK_EQ(V8_INFINITY, StrtodChar("18", 307));
   CHECK_EQ(17e307, StrtodChar("17", 307));
-  CHECK_EQ(std::numeric_limits<double>::infinity(), StrtodChar("0000001", 309));
+  CHECK_EQ(V8_INFINITY, StrtodChar("0000001", 309));
   CHECK_EQ(1e308, StrtodChar("00000001", 308));
   CHECK_EQ(1234e305, StrtodChar("00000001234", 305));
   CHECK_EQ(1234e304, StrtodChar("000000001234", 304));
-  CHECK_EQ(std::numeric_limits<double>::infinity(),
-           StrtodChar("0000000018", 307));
+  CHECK_EQ(V8_INFINITY, StrtodChar("0000000018", 307));
   CHECK_EQ(17e307, StrtodChar("0000000017", 307));
-  CHECK_EQ(std::numeric_limits<double>::infinity(), StrtodChar("1000000", 303));
+  CHECK_EQ(V8_INFINITY, StrtodChar("1000000", 303));
   CHECK_EQ(1e308, StrtodChar("100000", 303));
   CHECK_EQ(1234e305, StrtodChar("123400000", 300));
   CHECK_EQ(1234e304, StrtodChar("123400000", 299));
-  CHECK_EQ(std::numeric_limits<double>::infinity(),
-           StrtodChar("180000000", 300));
+  CHECK_EQ(V8_INFINITY, StrtodChar("180000000", 300));
   CHECK_EQ(17e307, StrtodChar("170000000", 300));
-  CHECK_EQ(std::numeric_limits<double>::infinity(),
-           StrtodChar("00000001000000", 303));
+  CHECK_EQ(V8_INFINITY, StrtodChar("00000001000000", 303));
   CHECK_EQ(1e308, StrtodChar("000000000000100000", 303));
   CHECK_EQ(1234e305, StrtodChar("00000000123400000", 300));
   CHECK_EQ(1234e304, StrtodChar("0000000123400000", 299));
-  CHECK_EQ(std::numeric_limits<double>::infinity(),
-           StrtodChar("00000000180000000", 300));
+  CHECK_EQ(V8_INFINITY, StrtodChar("00000000180000000", 300));
   CHECK_EQ(17e307, StrtodChar("00000000170000000", 300));
   CHECK_EQ(1.7976931348623157E+308, StrtodChar("17976931348623157", 292));
   CHECK_EQ(1.7976931348623158E+308, StrtodChar("17976931348623158", 292));
-  CHECK_EQ(std::numeric_limits<double>::infinity(),
-           StrtodChar("17976931348623159", 292));
+  CHECK_EQ(V8_INFINITY, StrtodChar("17976931348623159", 292));
 
   // The following number is the result of 89255.0/1e22. Both floating-point
   // numbers can be accurately represented with doubles. However on Linux,x86
   // the floating-point stack is set to 80bits and the double-rounding
   // introduces an error.
   CHECK_EQ(89255e-22, StrtodChar("89255", -22));
 
   // Some random values.
   CHECK_EQ(358416272e-33, StrtodChar("358416272", -33));
   CHECK_EQ(104110013277974872254e-225,
@@ skipping 157 matching lines @@
   DiyFp upper_boundary;
   Bignum input_digits;
   input_digits.AssignDecimalString(buffer);
   if (to_check == 0.0) {
     const double kMinDouble = 4e-324;
     // Check that the buffer*10^exponent < (0 + kMinDouble)/2.
     Double d(kMinDouble);
     d.NormalizedBoundaries(&lower_boundary, &upper_boundary);
     return CompareBignumToDiyFp(input_digits, exponent, lower_boundary) <= 0;
   }
-  if (to_check == std::numeric_limits<double>::infinity()) {
+  if (to_check == V8_INFINITY) {
     const double kMaxDouble = 1.7976931348623157e308;
     // Check that the buffer*10^exponent >= boundary between kMaxDouble and inf.
     Double d(kMaxDouble);
     d.NormalizedBoundaries(&lower_boundary, &upper_boundary);
     return CompareBignumToDiyFp(input_digits, exponent, upper_boundary) >= 0;
   }
   Double d(to_check);
   d.NormalizedBoundaries(&lower_boundary, &upper_boundary);
   if ((d.Significand() & 1) == 0) {
     return CompareBignumToDiyFp(input_digits, exponent, lower_boundary) >= 0 &&
@@ skipping 50 matching lines @@
         buffer[pos++] = rng.NextInt(10) + '0';
       }
       int exponent = DeterministicRandom() % (308*2 + 1) - 308 - length;
       buffer[pos] = '\0';
       Vector<const char> vector(buffer, pos);
       double strtod_result = Strtod(vector, exponent);
       CHECK(CheckDouble(vector, exponent, strtod_result));
     }
   }
 }