Add integer min/max constants to globals.h

R=ager@google.com

BUG=
TEST=

Review URL: https://chromiumcodereview.appspot.com//9363018

git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@4024 260f80e4-7a28-3924-810f-c04153c831b5

runtime/platform/globals.h

@@ -130,11 +130,18 @@
 
 
 // The following macro works on both 32 and 64-bit platforms.
-// Usage: instead of writing 0x1234567890123456
+// Usage: instead of writing 0x1234567890123456ULL
 //      write DART_2PART_UINT64_C(0x12345678,90123456);
 #define DART_2PART_UINT64_C(a, b)                                              \
                  (((static_cast<uint64_t>(a) << 32) + 0x##b##u))
 
+// Integer constants.
+const int32_t kMinInt32 = 0x80000000;
+const int32_t kMaxInt32 = 0x7FFFFFFF;
+const uint32_t kMaxUint32 = 0xFFFFFFFF;
+const int64_t kMinInt64 = DART_INT64_C(0x8000000000000000);
+const int64_t kMaxInt64 = DART_INT64_C(0x7FFFFFFFFFFFFFFF);
+const uint64_t kMaxUint64 = DART_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF);
 
 // Types for native machine words. Guaranteed to be able to hold pointers and
 // integers.

runtime/vm/bigint_operations_test.cc

@@ -78,22 +78,18 @@ TEST_CASE(BigintInt64) {
   EXPECT_EQ(0, BigintOperations::Compare(big, big_test));
 
   const Bigint& one = Bigint::Handle(BigintOperations::NewFromInt64(1));
-  const int64_t kMaxValue64 =
-      static_cast<int64_t>(DART_2PART_UINT64_C(0x7FFFFFFF, FFFFFFFF));
-  const int64_t kMinValue64 =
-      static_cast<int64_t>(DART_2PART_UINT64_C(0x80000000, 00000000));
-  big = BigintOperations::NewFromInt64(kMinValue64);
+  big = BigintOperations::NewFromInt64(kMinInt64);
   EXPECT(BigintOperations::FitsIntoInt64(big));
   int64_t back = BigintOperations::ToInt64(big);
-  EXPECT_EQ(kMinValue64, back);
+  EXPECT_EQ(kMinInt64, back);
 
   big = BigintOperations::Subtract(big, one);
   EXPECT(!BigintOperations::FitsIntoInt64(big));
 
-  big = BigintOperations::NewFromInt64(kMaxValue64);
+  big = BigintOperations::NewFromInt64(kMaxInt64);
   EXPECT(BigintOperations::FitsIntoInt64(big));
   back = BigintOperations::ToInt64(big);
-  EXPECT_EQ(kMaxValue64, back);
+  EXPECT_EQ(kMaxInt64, back);
 
   big = BigintOperations::Add(big, one);
   EXPECT(!BigintOperations::FitsIntoInt64(big));
@@ -101,19 +97,16 @@ TEST_CASE(BigintInt64) {
 
 
 TEST_CASE(BigintUint64) {
-  const uint64_t kMax =
-      static_cast<uint64_t>(DART_2PART_UINT64_C(0xFFFFFFFF, FFFFFFFF));
-
   const Bigint& one = Bigint::Handle(BigintOperations::NewFromUint64(1));
   EXPECT(BigintOperations::FitsIntoInt64(one));
   EXPECT(BigintOperations::FitsIntoUint64(one));
 
-  Bigint& big = Bigint::Handle(BigintOperations::NewFromUint64(kMax));
+  Bigint& big = Bigint::Handle(BigintOperations::NewFromUint64(kMaxUint64));
   EXPECT(!BigintOperations::FitsIntoInt64(big));
   EXPECT(BigintOperations::FitsIntoUint64(big));
 
   uint64_t back = BigintOperations::ToUint64(big);
-  EXPECT_EQ(kMax, back);
+  EXPECT_EQ(kMaxUint64, back);
 
   big = BigintOperations::Add(big, one);
   EXPECT(!BigintOperations::FitsIntoInt64(big));

runtime/vm/dart_api_impl_test.cc

@@ -361,7 +361,7 @@ TEST_CASE(IntegerValues) {
 
 
 TEST_CASE(IntegerFitsIntoInt64) {
-  Dart_Handle max = Dart_NewInteger(DART_INT64_C(0x7FFFFFFFFFFFFFFF));
+  Dart_Handle max = Dart_NewInteger(kMaxInt64);
   EXPECT(Dart_IsInteger(max));
   bool fits = false;
   Dart_Handle result = Dart_IntegerFitsIntoInt64(max, &fits);
@@ -375,7 +375,7 @@ TEST_CASE(IntegerFitsIntoInt64) {
   EXPECT_VALID(result);
   EXPECT(!fits);
 
-  Dart_Handle min = Dart_NewInteger(DART_INT64_C(-0x8000000000000000));
+  Dart_Handle min = Dart_NewInteger(kMaxInt64);
   EXPECT(Dart_IsInteger(min));
   fits = false;
   result = Dart_IntegerFitsIntoInt64(min, &fits);

runtime/vm/object_test.cc

@@ -222,11 +222,11 @@ TEST_CASE(Smi) {
   EXPECT(Smi::IsValid(-15));
   // Upper two bits must be either 00 or 11.
 #if defined(ARCH_IS_64_BIT)
-  EXPECT(!Smi::IsValid(0x7FFFFFFFFFFFFFFF));
+  EXPECT(!Smi::IsValid(kMaxInt64));
   EXPECT(Smi::IsValid(0x3FFFFFFFFFFFFFFF));
   EXPECT(Smi::IsValid(0xFFFFFFFFFFFFFFFF));
 #else
-  EXPECT(!Smi::IsValid(0x7FFFFFFF));
+  EXPECT(!Smi::IsValid(kMaxInt32));
   EXPECT(Smi::IsValid(0x3FFFFFFF));
   EXPECT(Smi::IsValid(0xFFFFFFFF));
 #endif